[INFO] Initializing environment for https://gitcode.com/pre-commit-clang/mirrors-clang-format. [INFO] Installing environment for https://gitcode.com/pre-commit-clang/mirrors-clang-format. [INFO] Once installed this environment will be reused. [INFO] This may take a few minutes... clang-format.............................................................Failed - hook id: clang-format - files were modified by this hook All changes made by hooks: diff --git a/src/runtime/core/src/stream/stream.cc b/src/runtime/core/src/stream/stream.cc old mode 100755 new mode 100644 index bc6b697..8d71ca9 --- a/src/runtime/core/src/stream/stream.cc +++ b/src/runtime/core/src/stream/stream.cc @@ -55,7 +55,7 @@ namespace cce { namespace runtime { namespace { -void CheckAndPrintPlaceHolder(const LaunchParam &launchParam, const uint32_t offset, std::stringstream &ss) +void CheckAndPrintPlaceHolder(const LaunchParam& launchParam, const uint32_t offset, std::stringstream& ss) { for (uint16_t i = 0; i < launchParam.placeHoderNum; i++) { if (offset == launchParam.placeHoderPtr[i].addrOffset) { @@ -90,9 +90,7 @@ __THREAD_LOCAL__ bool Stream::isNeedStreamAsyncRecycle_ = false; constexpr uint64_t TASK_SENDING_WAIT_CHECK_TIME = 840000U; constexpr uint16_t TASK_SENDING_WAIT_CHECK_COUNT = 2U; constexpr uint16_t SQE_DEPTH_1k = 1024U; -Stream::Stream(Device * const dev, const uint32_t prio) : Stream(dev, prio, 0U) -{ -} +Stream::Stream(Device* const dev, const uint32_t prio) : Stream(dev, prio, 0U) {} Stream::Stream(Device* const dev, const uint32_t prio, const uint32_t stmFlags, DvppGrp* const dvppGrp) : NoCopy(), @@ -153,25 +151,24 @@ Stream::Stream(Device* const dev, const uint32_t prio, const uint32_t stmFlags, hcclIndex_(UINT16_MAX), syncTimeout_(-1), abortStatus_(RT_ERROR_NONE) -{ -} +{} -Stream::Stream(const Context * const stmCtx, const uint32_t prio) : Stream(stmCtx->Device_(), prio) -{ -} +Stream::Stream(const Context* const stmCtx, const uint32_t prio) : Stream(stmCtx->Device_(), prio) {} -Stream::Stream(const Context * const stmCtx, const uint32_t prio, - const uint32_t stmFlags) : Stream(stmCtx->Device_(), prio, stmFlags) -{ -} +Stream::Stream(const Context* const stmCtx, const uint32_t prio, const uint32_t stmFlags) + : Stream(stmCtx->Device_(), prio, stmFlags) +{} Stream::~Stream() { ResetEmbeddedInnerHandle(this); if (device_ != nullptr) { if ((device_->GetDevStatus() != RT_ERROR_NONE) && (this->GetBindFlag())) { - RT_LOG(RT_LOG_WARNING, "Device fault and the model binds this stream, device_id=%u, stream_id=%d, " - "Cannot delete.", device_->Id_(), streamId_); + RT_LOG( + RT_LOG_WARNING, + "Device fault and the model binds this stream, device_id=%u, stream_id=%d, " + "Cannot delete.", + device_->Id_(), streamId_); return; } @@ -183,8 +180,8 @@ Stream::~Stream() if (Runtime::Instance()->GetDisableThread()) { if (dvppGrp_ != nullptr) { - (void)device_->Driver_()->StreamUnBindLogicCq(device_->Id_(), device_->DevGetTsId(), - streamId_, dvppGrp_->getLogicCqId()); + (void)device_->Driver_()->StreamUnBindLogicCq( + device_->Id_(), device_->DevGetTsId(), streamId_, dvppGrp_->getLogicCqId()); } else { (void)device_->GetStreamSqCqManage()->FreeLogicCq(static_cast(streamId_)); } @@ -206,7 +203,7 @@ Stream::~Stream() FreeStreamId(); } - for (void * const switchArg : switchNArg_) { + for (void* const switchArg : switchNArg_) { TIMESTAMP_BEGIN(rtStreamDestroy_drvMemFreeManaged_arg); (void)device_->Driver_()->DevMemFree(switchArg, device_->Id_()); TIMESTAMP_END(rtStreamDestroy_drvMemFreeManaged_arg); @@ -220,7 +217,7 @@ Stream::~Stream() (void)device_->Driver_()->DevMemFree(memContainOverflowAddr_, device_->Id_()); memContainOverflowAddr_ = nullptr; } - for (void * const addr : devTilingTblAddr) { + for (void* const addr : devTilingTblAddr) { RT_LOG(RT_LOG_INFO, "Id=%u, devCopyMem=%p", device_->Id_(), addr); (void)device_->Driver_()->DevMemFree(addr, device_->Id_()); } @@ -230,9 +227,9 @@ Stream::~Stream() } if (IsSoftwareSqEnable() && (GetSqBaseAddr() != 0U)) { - SqAddrMemoryOrder *sqAddrMemoryManage = device_->GetSqAddrMemoryManage(); + SqAddrMemoryOrder* sqAddrMemoryManage = device_->GetSqAddrMemoryManage(); if (sqAddrMemoryManage != nullptr) { - (void)sqAddrMemoryManage->FreeSqAddr(RtValueToPtr(GetSqBaseAddr()), GetSqMemOrderType()); + (void)sqAddrMemoryManage->FreeSqAddr(RtValueToPtr(GetSqBaseAddr()), GetSqMemOrderType()); } } @@ -268,7 +265,7 @@ Stream::~Stream() DELETE_A(posToTaskIdMap_); DELETE_A(wrRecordQueue_.queue); DELETE_A(sqeBuffer_); - } catch(...) { + } catch (...) { } latestModelId_ = MAX_INT32_NUM; @@ -289,14 +286,14 @@ void Stream::FreeStreamId() const RT_LOG(RT_LOG_INFO, "Free stream_id=%d.", streamId_); if (!IsSoftwareSqEnable() && !IsAutoSplitSq()) { TIMESTAMP_BEGIN(rtStreamDestroy_drvStreamIdFree); - uint32_t drvFlag = ((flags_ & RT_STREAM_CP_PROCESS_USE) != 0) ? - static_cast(TSDRV_FLAG_REMOTE_ID) : 0U; + uint32_t drvFlag = + ((flags_ & RT_STREAM_CP_PROCESS_USE) != 0) ? static_cast(TSDRV_FLAG_REMOTE_ID) : 0U; (void)device_->GetStreamSqCqManage()->DeAllocStreamSqCq(static_cast(streamId_), cqId_, drvFlag); } - Driver * const dev = device_->Driver_(); + Driver* const dev = device_->Driver_(); const rtError_t ret = dev->StreamIdFree(streamId_, device_->Id_(), device_->DevGetTsId(), flags_); - Runtime * const rtInstance = Runtime::Instance(); + Runtime* const rtInstance = Runtime::Instance(); if ((ret != RT_ERROR_NONE) && (rtInstance->excptCallBack_ != nullptr)) { Runtime::Instance()->excptCallBack_(RT_EXCEPTION_STREAM_ID_FREE_FAILED); } @@ -310,13 +307,15 @@ rtError_t Stream::CheckGroup() (void)device_->GetGroupCount(&groupCount); if ((groupCount > 1U) && (device_->DefaultGroup() == -1) && (device_->GetGroupId() == UNINIT_GROUP_ID)) { if ((flags_ & RT_STREAM_PRIMARY_DEFAULT) != 0U) { - RT_LOG(RT_LOG_WARNING, "Multiple groups have been created, but no default group exists." - " Please use rtSetGroup to set a group first!"); + RT_LOG( + RT_LOG_WARNING, "Multiple groups have been created, but no default group exists." + " Please use rtSetGroup to set a group first!"); } else { - RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1018, - "Computing power group check", + RT_LOG_OUTER_MSG_IMPL( + ErrorCode::EE1018, "Computing power group check", "When a stream is created, the device has multiple computing power groups. " - "You must call the rtSetGroup API to specify the computing power group to be used for the current operation"); + "You must call the rtSetGroup API to specify the computing power group to be used for the current " + "operation"); return RT_ERROR_GROUP_NOT_SET; } } @@ -374,8 +373,7 @@ bool Stream::CheckASyncRecycle() const bool isDisableThread = Runtime::Instance()->GetDisableThread(); if ((!GetBindFlag()) && (!IsBindDvppGrp()) && isDisableThread && (device_->IsSupportFeature(RtOptionalFeatureType::RT_FEATURE_STREAM_RECLAIM_ASYNC)) && - (device_->Driver_()->GetRunMode() == RT_RUN_MODE_ONLINE) - && streamFastSync_) { + (device_->Driver_()->GetRunMode() == RT_RUN_MODE_ONLINE) && streamFastSync_) { return true; } return false; @@ -383,9 +381,9 @@ bool Stream::CheckASyncRecycle() rtError_t Stream::CreateArgRecycleList(uint32_t size) { - argRecycleList_ = new (std::nothrow) RecycleArgs *[size]{}; + argRecycleList_ = new (std::nothrow) RecycleArgs* [size] {}; if (argRecycleList_ == nullptr) { - RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1013, sizeof(RecycleArgs *) * size, "new"); + RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1013, sizeof(RecycleArgs*) * size, "new"); return RT_ERROR_MEMORY_ALLOCATION; } argRecycleListSize_ = size; @@ -417,10 +415,9 @@ void Stream::DestroyArgRecycleList(uint32_t size) return; } -bool Stream::AddArgToRecycleList(TaskInfo * const tsk) +bool Stream::AddArgToRecycleList(TaskInfo* const tsk) { - const bool isAicTask = (tsk->type == TS_TASK_TYPE_KERNEL_AICORE) || - (tsk->type == TS_TASK_TYPE_KERNEL_AIVEC); + const bool isAicTask = (tsk->type == TS_TASK_TYPE_KERNEL_AICORE) || (tsk->type == TS_TASK_TYPE_KERNEL_AIVEC); if (isAicTask && static_cast(tsk->u.aicTaskInfo.mixOpt) != 0U) { RT_LOG(RT_LOG_DEBUG, "mix Optimized"); return false; @@ -435,7 +432,7 @@ bool Stream::AddArgToRecycleList(TaskInfo * const tsk) return false; } - RecycleArgs *recycleArgs = *(argRecycleList_ + argRecycleListTail_); + RecycleArgs* recycleArgs = *(argRecycleList_ + argRecycleListTail_); if (isAicTask) { recycleArgs->argHandle = tsk->u.aicTaskInfo.comm.argHandle; @@ -465,7 +462,7 @@ RecycleArgs* Stream::GetNextRecycleArg(void) } /* update the queue head */ - RecycleArgs *recycleArgs = *(argRecycleList_ + argRecycleListHead_); + RecycleArgs* recycleArgs = *(argRecycleList_ + argRecycleListHead_); argRecycleListHead_ = (argRecycleListHead_ + 1U) % argRecycleListSize_; return recycleArgs; @@ -473,7 +470,7 @@ RecycleArgs* Stream::GetNextRecycleArg(void) void Stream::ProcArgRecycleList(void) { - RecycleArgs *recycleArgs = GetNextRecycleArg(); + RecycleArgs* recycleArgs = GetNextRecycleArg(); while (recycleArgs != nullptr) { if (recycleArgs->argHandle != nullptr) { (void)Device_()->ArgLoader_()->Release(recycleArgs->argHandle); @@ -489,23 +486,23 @@ void Stream::ProcArgRecycleList(void) } } -bool Stream::IsReclaimAsync(const TaskInfo * const tsk) const +bool Stream::IsReclaimAsync(const TaskInfo* const tsk) const { - if ((tsk->type == TS_TASK_TYPE_FFTS_PLUS) ||(tsk->type == TS_TASK_TYPE_NOTIFY_WAIT) || + if ((tsk->type == TS_TASK_TYPE_FFTS_PLUS) || (tsk->type == TS_TASK_TYPE_NOTIFY_WAIT) || (tsk->type == TS_TASK_TYPE_NOTIFY_RECORD)) { - return true; + return true; } if (tsk->type == TS_TASK_TYPE_MEMCPY) { const uint32_t copyTypeFlag = tsk->u.memcpyAsyncTaskInfo.copyType; if (device_->IsSupportFeature(RtOptionalFeatureType::RT_FEATURE_TASK_MEMCOPY_RECLAIM_ASYNC_WITHOUR_PCIE_BAR)) { if ((copyTypeFlag == RT_MEMCPY_DIR_H2D) || (copyTypeFlag == RT_MEMCPY_DIR_D2H) || - (copyTypeFlag == RT_MEMCPY_DIR_D2D_PCIe)) { + (copyTypeFlag == RT_MEMCPY_DIR_D2D_PCIe)) { return false; } return true; } else { - if ((copyTypeFlag != RT_MEMCPY_DIR_D2D_SDMA) && (copyTypeFlag != RT_MEMCPY_DIR_SDMA_AUTOMATIC_ADD) - && (copyTypeFlag != RT_MEMCPY_ADDR_D2D_SDMA)) { + if ((copyTypeFlag != RT_MEMCPY_DIR_D2D_SDMA) && (copyTypeFlag != RT_MEMCPY_DIR_SDMA_AUTOMATIC_ADD) && + (copyTypeFlag != RT_MEMCPY_ADDR_D2D_SDMA)) { return false; } return true; @@ -514,11 +511,10 @@ bool Stream::IsReclaimAsync(const TaskInfo * const tsk) const return false; } -bool Stream::IsNeedPostProc(const TaskInfo * const tsk) const +bool Stream::IsNeedPostProc(const TaskInfo* const tsk) const { if (tsk->stream->isHasPcieBar_) { - const bool isAicTask = (tsk->type == TS_TASK_TYPE_KERNEL_AICORE) || - (tsk->type == TS_TASK_TYPE_KERNEL_AIVEC); + const bool isAicTask = (tsk->type == TS_TASK_TYPE_KERNEL_AICORE) || (tsk->type == TS_TASK_TYPE_KERNEL_AIVEC); if (isAicTask) { // some aicpu launch size < 1K, but no use pcie const uint8_t mixType = @@ -554,31 +550,30 @@ rtError_t Stream::EschedManage(const bool enFlag) const const int32_t curTid = mmGetTid(); const uint32_t devId = device_->Id_(); const uint32_t tsId = device_->DevGetTsId(); - constexpr uint64_t eventBitmap = (0x1ULL << static_cast(EVENT_TS_CALLBACK_MSG)); // EVENT TYPE + constexpr uint64_t eventBitmap = (0x1ULL << static_cast(EVENT_TS_CALLBACK_MSG)); // EVENT TYPE - Runtime * const rtInstance = Runtime::Instance(); + Runtime* const rtInstance = Runtime::Instance(); if (!rtInstance->IsStreamSyncEsched()) { return error; } grpId = rtInstance->GetStreamSyncEschedGrpID(); if (enFlag) { - error = NpuDriver::StreamEnableStmSyncEsched(devId, tsId, static_cast(streamId_), - grpId, EVENT_TS_CALLBACK_MSG); + error = NpuDriver::StreamEnableStmSyncEsched( + devId, tsId, static_cast(streamId_), grpId, EVENT_TS_CALLBACK_MSG); COND_RETURN_WITH_NOLOG(error != RT_ERROR_NONE, error); } rtInstance->StreamSyncEschedLock(); - std::map::iterator it = - rtInstance->eschedMap_.find(curTid); + std::map::iterator it = rtInstance->eschedMap_.find(curTid); if (it != rtInstance->eschedMap_.end()) { rtInstance->StreamSyncEschedUnLock(); return RT_ERROR_NONE; } if (rtInstance->lastEschedTid_ >= STMSYNC_ESCHED_MAX_THREAD_NUM) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, - "The number of threads subscribing to synchronous scheduling exceeds the maximum value %u.", + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "The number of threads subscribing to synchronous scheduling exceeds the maximum value %u.", STMSYNC_ESCHED_MAX_THREAD_NUM); rtInstance->StreamSyncEschedUnLock(); return RT_ERROR_INVALID_VALUE; @@ -594,8 +589,8 @@ rtError_t Stream::EschedManage(const bool enFlag) const error = NpuDriver::EschedSubscribeEvent(static_cast(devId), grpId, eschedTid, eventBitmap); COND_RETURN_WITH_NOLOG(error != RT_ERROR_NONE, error); - RT_LOG(RT_LOG_DEBUG, "EschedSubscribeEvent devId=%u, eschedTid=%u, eventBitmap=%llu.", - devId, eschedTid, eventBitmap); + RT_LOG( + RT_LOG_DEBUG, "EschedSubscribeEvent devId=%u, eschedTid=%u, eventBitmap=%llu.", devId, eschedTid, eventBitmap); rtEschedEventSummary_t evt = {}; (void)NpuDriver::EschedWaitEvent(static_cast(devId), grpId, eschedTid, 0, &evt); @@ -606,14 +601,14 @@ rtError_t Stream::EschedManage(const bool enFlag) const rtError_t Stream::AllocStreamIdFromDriver() { TIMESTAMP_BEGIN(rtStreamCreate_drvStreamIdAlloc); - const rtError_t error = device_->Driver_()->StreamIdAlloc(&streamId_, device_->Id_(), device_->DevGetTsId(), priority_); + const rtError_t error = + device_->Driver_()->StreamIdAlloc(&streamId_, device_->Id_(), device_->DevGetTsId(), priority_); device_->GetStreamSqCqManage()->SetStreamIdToStream(static_cast(streamId_), this); TIMESTAMP_END(rtStreamCreate_drvStreamIdAlloc); if (error != RT_ERROR_NONE) { RT_LOG(RT_LOG_ERROR, "Failed to alloc stream id, retCode=%#x.", static_cast(error)); if ((error == RT_ERROR_DRV_NO_RESOURCES) || (error == RT_ERROR_DRV_NO_STREAM_RESOURCES)) { - RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1023, "Alloc Stream resource", - "Too many streams are created"); + RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1023, "Alloc Stream resource", "Too many streams are created"); } return error; } @@ -636,27 +631,31 @@ rtError_t Stream::Setup() taskPublicBuffSize_ = isDisableThread ? STREAM_PUBLIC_TASK_BUFF_SIZE : STREAM_TASK_BUFF_SIZE; taskPublicBuff_ = new (std::nothrow) uint32_t[taskPublicBuffSize_]; TIMESTAMP_END(rtStreamCreate_taskPublicBuff); - COND_RETURN_AND_MSG_OUTER(taskPublicBuff_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, - sizeof(uint32_t) * taskPublicBuffSize_, "new"); + COND_RETURN_AND_MSG_OUTER( + taskPublicBuff_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, sizeof(uint32_t) * taskPublicBuffSize_, + "new"); } if (CheckASyncRecycle() && !IsSeparateSendAndRecycle()) { SetIsSupportASyncRecycle(true); davinciTaskListSize_ = STREAM_PUBLIC_TASK_BUFF_SIZE; davinciTaskList_ = new (std::nothrow) uint32_t[davinciTaskListSize_]; - COND_RETURN_AND_MSG_OUTER(davinciTaskList_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, + COND_RETURN_AND_MSG_OUTER( + davinciTaskList_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, sizeof(uint32_t) * davinciTaskListSize_, "new"); } posToTaskIdMapSize_ = rtsqDepth; posToTaskIdMap_ = new (std::nothrow) uint16_t[posToTaskIdMapSize_]; - COND_RETURN_AND_MSG_OUTER(posToTaskIdMap_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, - sizeof(uint16_t) * posToTaskIdMapSize_, "new"); + COND_RETURN_AND_MSG_OUTER( + posToTaskIdMap_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, sizeof(uint16_t) * posToTaskIdMapSize_, + "new"); - const errno_t ret = memset_s(posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0XFF, - posToTaskIdMapSize_ * sizeof(uint16_t)); + const errno_t ret = + memset_s(posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0XFF, posToTaskIdMapSize_ * sizeof(uint16_t)); if (ret != EOK) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Failed to call memset_s to set posToTaskIdMap_, dest=%p, dest_max=%zu, c=0xFF, count=%zu, retCode=%d.", posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), posToTaskIdMapSize_ * sizeof(uint16_t), ret); return RT_ERROR_SEC_HANDLE; @@ -684,8 +683,9 @@ rtError_t Stream::Setup() } if ((flags_ & RT_STREAM_AICPU) != 0U) { error = Runtime::Instance()->AllocAiCpuStreamId(streamId_); - ERROR_RETURN(error, "Failed to alloc aicpu stream id, retCode=%#x, stream_id=%d.", - static_cast(error), streamId_); + ERROR_RETURN( + error, "Failed to alloc aicpu stream id, retCode=%#x, stream_id=%d.", static_cast(error), + streamId_); InitEmbeddedInnerHandle(this); StreamStateCallbackManager::Instance().Notify(this, true); return RT_ERROR_NONE; // AiCpuStream not participate in scheduling @@ -699,19 +699,18 @@ rtError_t Stream::Setup() RT_LOG(RT_LOG_DEBUG, "Alloc stream, stream_id=%d", streamId_); error = AllocExecutedTimesSvm(); - ERROR_RETURN(error, "Failed to alloc svm for executed times, retCode=%#x.", - static_cast(error)); + ERROR_RETURN(error, "Failed to alloc svm for executed times, retCode=%#x.", static_cast(error)); SetSatMode(device_->GetSatMode()); TIMESTAMP_BEGIN(rtStreamCreate_AllocStreamSqCq); /**** alloc sq cq id *****/ - const auto stmSqCqManage = const_cast(device_->GetStreamSqCqManage()); + const auto stmSqCqManage = const_cast(device_->GetStreamSqCqManage()); uint32_t tmpSqId = 0U; uint32_t tmpCqId = 0U; error = stmSqCqManage->AllocStreamSqCq(this, priority_, 0U, tmpSqId, tmpCqId); if (error == RT_ERROR_DRV_NO_RESOURCES) { - DeviceSqCqPool *sqcqPool = device_->GetDeviceSqCqManage(); + DeviceSqCqPool* sqcqPool = device_->GetDeviceSqCqManage(); if ((sqcqPool->GetSqCqPoolFreeResNum() == 0U) && (Context_() != nullptr)) { (void)Context_()->TryRecycleCaptureModelResource(1U, 0U, nullptr); } @@ -726,12 +725,13 @@ rtError_t Stream::Setup() TIMESTAMP_END(rtStreamCreate_AllocStreamSqCq); if (error != RT_ERROR_NONE) { if ((error == RT_ERROR_DRV_NO_RESOURCES) || (error == RT_ERROR_DEVICE_SQCQ_POOL_RESOURCE_FULL)) { - RT_LOG(RT_LOG_ERROR, "Alloc sq cq failed, stream_id=%d, retCode=%#x.", streamId_, + RT_LOG( + RT_LOG_ERROR, "Alloc sq cq failed, stream_id=%d, retCode=%#x.", streamId_, static_cast(error)); - RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1023, "Alloc Stream resource", - "Too many streams are created"); + RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1023, "Alloc Stream resource", "Too many streams are created"); } else { - RT_LOG_INNER_MSG(RT_LOG_ERROR, "Alloc sq cq failed, stream_id=%d, retCode=%#x.", streamId_, + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Alloc sq cq failed, stream_id=%d, retCode=%#x.", streamId_, static_cast(error)); } device_->GetStreamSqCqManage()->DelStreamIdToStream(static_cast(streamId_)); @@ -742,8 +742,8 @@ rtError_t Stream::Setup() sqId_ = tmpSqId; cqId_ = tmpCqId; - RT_LOG(RT_LOG_DEBUG, "[StreamSetup]alloc sq cq success: stream_id=%d, sqId=%u, cqId=%u", streamId_, tmpSqId, - tmpCqId); + RT_LOG( + RT_LOG_DEBUG, "[StreamSetup]alloc sq cq success: stream_id=%d, sqId=%u, cqId=%u", streamId_, tmpSqId, tmpCqId); const bool starsFlag = device_->IsStarsPlatform(); if (isDisableThread && (!starsFlag)) { @@ -759,18 +759,18 @@ rtError_t Stream::Setup() if (starsFlag) { // get virtual addr from Driver by sqId. uint32_t addrLen = 0U; - error = device_->Driver_()->GetSqRegVirtualAddrBySqid(static_cast(device_->Id_()), - device_->DevGetTsId(), - sqId_, &sqRegVirtualAddr_, &addrLen); - ERROR_RETURN_MSG_INNER(error, "Failed to get sq reg virtual addr, deviceId=%u, sqId=%u.", device_->Id_(), sqId_); + error = device_->Driver_()->GetSqRegVirtualAddrBySqid( + static_cast(device_->Id_()), device_->DevGetTsId(), sqId_, &sqRegVirtualAddr_, &addrLen); + ERROR_RETURN_MSG_INNER( + error, "Failed to get sq reg virtual addr, deviceId=%u, sqId=%u.", device_->Id_(), sqId_); RT_LOG(RT_LOG_INFO, "Success to get sq=%u sq reg virtual addr length=%u.", sqId_, addrLen); if (device_->GetSocVersion() == "Ascend031") { sqRegVirtualAddr_ = RT_STARS_BASE_ADDR_78000000 + RT_SIMPLE_SQ0_STARS_P0_SQ_CFG4_0_REG + - sqId_ * RT_SIMPLE_SQ_OFFSET_1000 - STARS_SIMPLE_SQ_HEAD_OFFSET; + sqId_ * RT_SIMPLE_SQ_OFFSET_1000 - STARS_SIMPLE_SQ_HEAD_OFFSET; } error = SetSqRegVirtualAddrToDevice(sqRegVirtualAddr_); - ERROR_RETURN_MSG_INNER(error, "Failed to copy virtual addr to device, sqid=%u, error=%#x.", sqId_, - static_cast(error)); + ERROR_RETURN_MSG_INNER( + error, "Failed to copy virtual addr to device, sqid=%u, error=%#x.", sqId_, static_cast(error)); } TIMESTAMP_BEGIN(rtStreamCreate_CreateTaskResource); @@ -801,15 +801,16 @@ rtError_t Stream::Setup() error = EschedManage(true); COND_RETURN_WITH_NOLOG(error != RT_ERROR_NONE, error); - RT_LOG(RT_LOG_INFO, "stream setup end, stream_id=%d, IsTaskSink=%d, sqId=%u, cqId=%u, deviceId=%u, streamResId=%u", - streamId_, static_cast(IsTaskSink()), sqId_, cqId_, device_->Id_(), streamResId); + RT_LOG( + RT_LOG_INFO, "stream setup end, stream_id=%d, IsTaskSink=%d, sqId=%u, cqId=%u, deviceId=%u, streamResId=%u", + streamId_, static_cast(IsTaskSink()), sqId_, cqId_, device_->Id_(), streamResId); InitEmbeddedInnerHandle(this); StreamStateCallbackManager::Instance().Notify(this, true); return RT_ERROR_NONE; } -void Stream::UpdateSqCq(const rtDeviceSqCqInfo_t * const sqCqInfo) +void Stream::UpdateSqCq(const rtDeviceSqCqInfo_t* const sqCqInfo) { sqId_ = sqCqInfo->sqId; cqId_ = sqCqInfo->cqId; @@ -867,12 +868,14 @@ rtError_t Stream::SetupWithoutBindSq() SetIsSupportASyncRecycle(false); posToTaskIdMapSize_ = GetSqDepth(); posToTaskIdMap_ = new (std::nothrow) uint16_t[posToTaskIdMapSize_]; - COND_RETURN_AND_MSG_OUTER(posToTaskIdMap_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, - sizeof(uint16_t) * posToTaskIdMapSize_, "new"); + COND_RETURN_AND_MSG_OUTER( + posToTaskIdMap_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, sizeof(uint16_t) * posToTaskIdMapSize_, + "new"); - errno_t ret = memset_s(posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0XFF, - posToTaskIdMapSize_ * sizeof(uint16_t)); - COND_RETURN_ERROR_MSG_INNER(ret != EOK, RT_ERROR_STREAM_NEW, + errno_t ret = + memset_s(posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0XFF, posToTaskIdMapSize_ * sizeof(uint16_t)); + COND_RETURN_ERROR_MSG_INNER( + ret != EOK, RT_ERROR_STREAM_NEW, "Failed to call memset_s to set posToTaskIdMap_, dest=%p, dest_max=%zu, c=0xFF, count=%zu, retCode=%d.", posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), posToTaskIdMapSize_ * sizeof(uint16_t), ret); @@ -884,14 +887,13 @@ rtError_t Stream::SetupWithoutBindSq() RT_LOG(RT_LOG_DEBUG, "Alloc stream, stream_id=%d", streamId_); error = AllocExecutedTimesSvm(); - ERROR_RETURN(error, "Failed to alloc svm for executed times, retCode=%#x.", - static_cast(error)); + ERROR_RETURN(error, "Failed to alloc svm for executed times, retCode=%#x.", static_cast(error)); SetSatMode(device_->GetSatMode()); const bool starsFlag = device_->IsStarsPlatform(); /**** alloc sq cq id *****/ - const auto stmSqCqManage = RtPtrToUnConstPtr(device_->GetStreamSqCqManage()); + const auto stmSqCqManage = RtPtrToUnConstPtr(device_->GetStreamSqCqManage()); TIMESTAMP_BEGIN(rtStreamCreate_AllocLogicCq); error = AllocLogicCq(isDisableThread, starsFlag, stmSqCqManage); TIMESTAMP_END(rtStreamCreate_AllocLogicCq); @@ -905,19 +907,23 @@ rtError_t Stream::SetupWithoutBindSq() COND_RETURN_AND_MSG_OUTER(sqeBuffer_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, sqeBufferSize_, "new"); ret = memset_s(sqeBuffer_, sqeBufferSize_, 0U, sqeBufferSize_); - COND_RETURN_ERROR_MSG_INNER(ret != EOK, RT_ERROR_STREAM_NEW, - "Failed to call memset_s to set sqeBuffer_, dest=%p, dest_max=%u, c=0, count=%u, retCode=%d.", - sqeBuffer_, sqeBufferSize_, sqeBufferSize_, ret); + COND_RETURN_ERROR_MSG_INNER( + ret != EOK, RT_ERROR_STREAM_NEW, + "Failed to call memset_s to set sqeBuffer_, dest=%p, dest_max=%u, c=0, count=%u, retCode=%d.", sqeBuffer_, + sqeBufferSize_, sqeBufferSize_, ret); /* pre alloc sq and cq */ device_->GetDeviceSqCqManage()->PreAllocSqCq(); const uint64_t sqIdMemAddr = device_->AllocSqIdMemAddr(); - COND_RETURN_ERROR_MSG_INNER((sqIdMemAddr == 0UL), RT_ERROR_MEMORY_ALLOCATION, + COND_RETURN_ERROR_MSG_INNER( + (sqIdMemAddr == 0UL), RT_ERROR_MEMORY_ALLOCATION, "Failed to allocate memory for sq id, device_id=%u, stream_id=%d.", device_->Id_(), Id_()); SetSqIdMemAddr(sqIdMemAddr); - RT_LOG(RT_LOG_INFO, "stream setup end, stream_id=%d, IsTaskSink=%d, sqId=%u, cqId=%u, deviceId=%u, streamResId=%u, sqAddr=0x%llx", - streamId_, static_cast(IsTaskSink()), sqId_, cqId_, device_->Id_(), streamResId, sqAddr_); + RT_LOG( + RT_LOG_INFO, + "stream setup end, stream_id=%d, IsTaskSink=%d, sqId=%u, cqId=%u, deviceId=%u, streamResId=%u, sqAddr=0x%llx", + streamId_, static_cast(IsTaskSink()), sqId_, cqId_, device_->Id_(), streamResId, sqAddr_); InitEmbeddedInnerHandle(this); StreamStateCallbackManager::Instance().Notify(this, true); @@ -929,9 +935,9 @@ rtError_t Stream::InitAutoSplitBasicParams() SetSqDepth(STREAM_SQ_MAX_DEPTH); SetIsSupportASyncRecycle(false); streamSwitchInfo_ = new (std::nothrow) struct sq_switch_stream_info[1U](); - COND_PROC_RETURN_AND_MSG_OUTER(streamSwitchInfo_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, - RT_LOG(RT_LOG_ERROR, "new sq switch info failed, stream_id=%u.", Id_()), - sizeof(sq_switch_stream_info), "new"); + COND_PROC_RETURN_AND_MSG_OUTER( + streamSwitchInfo_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, + RT_LOG(RT_LOG_ERROR, "new sq switch info failed, stream_id=%u.", Id_()), sizeof(sq_switch_stream_info), "new"); return RT_ERROR_NONE; } @@ -939,12 +945,14 @@ rtError_t Stream::AllocPosToTaskIdMap() { posToTaskIdMapSize_ = GetSqDepth(); posToTaskIdMap_ = new (std::nothrow) uint16_t[posToTaskIdMapSize_]; - COND_RETURN_AND_MSG_OUTER(posToTaskIdMap_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, - sizeof(uint16_t) * posToTaskIdMapSize_, "new"); + COND_RETURN_AND_MSG_OUTER( + posToTaskIdMap_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, sizeof(uint16_t) * posToTaskIdMapSize_, + "new"); - errno_t ret = memset_s(posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0XFF, - posToTaskIdMapSize_ * sizeof(uint16_t)); - COND_RETURN_ERROR_MSG_INNER(ret != EOK, RT_ERROR_STREAM_NEW, + errno_t ret = + memset_s(posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0XFF, posToTaskIdMapSize_ * sizeof(uint16_t)); + COND_RETURN_ERROR_MSG_INNER( + ret != EOK, RT_ERROR_STREAM_NEW, "Failed to call memset_s to set posToTaskIdMap_, dest=%p, dest_max=%zu, c=0xFF, count=%zu, retCode=%d.", posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), posToTaskIdMapSize_ * sizeof(uint16_t), ret); @@ -954,8 +962,8 @@ rtError_t Stream::AllocPosToTaskIdMap() rtError_t Stream::AllocAutoSplitContext() { autoSplitCtx_ = new (std::nothrow) AutoSplitSqContext(); - COND_RETURN_AND_MSG_OUTER(autoSplitCtx_ == nullptr, RT_ERROR_STREAM_NEW, - ErrorCode::EE1013, sizeof(AutoSplitSqContext), "new"); + COND_RETURN_AND_MSG_OUTER( + autoSplitCtx_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, sizeof(AutoSplitSqContext), "new"); autoSplitCtx_->exposedStreamId = streamId_; autoSplitCtx_->curStreamSqeCount = 0U; @@ -970,9 +978,10 @@ rtError_t Stream::AllocSqeBufferForAutoSplit() COND_RETURN_AND_MSG_OUTER(sqeBuffer_ == nullptr, RT_ERROR_STREAM_NEW, ErrorCode::EE1013, sqeBufferSize_, "new"); errno_t ret = memset_s(sqeBuffer_, sqeBufferSize_, 0U, sqeBufferSize_); - COND_RETURN_ERROR_MSG_INNER(ret != EOK, RT_ERROR_STREAM_NEW, - "Failed to call memset_s to set sqeBuffer_, dest=%p, dest_max=%u, c=0, count=%u, retCode=%d.", - sqeBuffer_, sqeBufferSize_, sqeBufferSize_, ret); + COND_RETURN_ERROR_MSG_INNER( + ret != EOK, RT_ERROR_STREAM_NEW, + "Failed to call memset_s to set sqeBuffer_, dest=%p, dest_max=%u, c=0, count=%u, retCode=%d.", sqeBuffer_, + sqeBufferSize_, sqeBufferSize_, ret); return RT_ERROR_NONE; } @@ -981,8 +990,9 @@ rtError_t Stream::AllocStreamIdForAutoSplit() { const rtError_t error = AllocStreamIdFromDriver(); COND_RETURN_WITH_NOLOG(error != RT_ERROR_NONE, error); - RT_LOG(RT_LOG_DEBUG, "Alloc stream for auto split, master_stream_id=%d, cur_stream_id=%d", - GetExposedStreamId(), Id_()); + RT_LOG( + RT_LOG_DEBUG, "Alloc stream for auto split, master_stream_id=%d, cur_stream_id=%d", GetExposedStreamId(), + Id_()); return RT_ERROR_NONE; } @@ -991,9 +1001,10 @@ rtError_t Stream::AllocSqCqForAutoSplitWithRetry() rtDeviceSqCqInfo_t sqCqInfo = {}; rtError_t error = device_->GetDeviceSqCqManage()->AllocSqCqForAutoSplit(&sqCqInfo); if (error == RT_ERROR_DRV_NO_RESOURCES) { - RT_LOG(RT_LOG_DEBUG, "Auto-split SQ/CQ alloc no resources, retry recycling, master_stream_id=%d, cur_stream_id=%d", + RT_LOG( + RT_LOG_DEBUG, "Auto-split SQ/CQ alloc no resources, retry recycling, master_stream_id=%d, cur_stream_id=%d", GetExposedStreamId(), Id_()); - DeviceSqCqPool *sqcqPool = device_->GetDeviceSqCqManage(); + DeviceSqCqPool* sqcqPool = device_->GetDeviceSqCqManage(); if ((sqcqPool->GetSqCqPoolFreeResNum() == 0U) && (Context_() != nullptr)) { Context_()->TryRecycleCaptureModelResource(1U, 0U, nullptr); } @@ -1006,11 +1017,11 @@ rtError_t Stream::AllocSqCqForAutoSplitWithRetry() } if (error != RT_ERROR_NONE) { - RT_LOG(RT_LOG_ERROR, "[SqCqManage]Alloc sq cq fail, stream_id=%d, retCode=%#x.", - streamId_, static_cast(error)); + RT_LOG( + RT_LOG_ERROR, "[SqCqManage]Alloc sq cq fail, stream_id=%d, retCode=%#x.", streamId_, + static_cast(error)); if ((error == RT_ERROR_DRV_NO_RESOURCES) || (error == RT_ERROR_DEVICE_SQCQ_POOL_RESOURCE_FULL)) { - RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1023, "Alloc Stream resource", - "Too many streams are created"); + RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1023, "Alloc Stream resource", "Too many streams are created"); } return error; } @@ -1021,17 +1032,14 @@ rtError_t Stream::AllocSqCqForAutoSplitWithRetry() rtError_t Stream::SetupForAutoSplit() { - RT_LOG(RT_LOG_DEBUG, "Enter SetupForAutoSplit, master_stream_id=%d, cur_stream_id=%d", - GetExposedStreamId(), Id_()); + RT_LOG(RT_LOG_DEBUG, "Enter SetupForAutoSplit, master_stream_id=%d, cur_stream_id=%d", GetExposedStreamId(), Id_()); const bool isDisableThread = Runtime::Instance()->GetDisableThread(); rtError_t error = InitAutoSplitBasicParams(); - ERROR_RETURN_MSG_INNER(error, "Init auto split basic params failed, retCode=%#x.", - static_cast(error)); + ERROR_RETURN_MSG_INNER(error, "Init auto split basic params failed, retCode=%#x.", static_cast(error)); error = AllocPosToTaskIdMap(); - ERROR_RETURN_MSG_INNER(error, "Alloc pos to task id map failed, retCode=%#x.", - static_cast(error)); + ERROR_RETURN_MSG_INNER(error, "Alloc pos to task id map failed, retCode=%#x.", static_cast(error)); error = CreateStreamArgRes(); ERROR_RETURN_MSG_INNER(error, "Create stream arg res failed."); @@ -1039,18 +1047,17 @@ rtError_t Stream::SetupForAutoSplit() error = AllocStreamIdForAutoSplit(); if (error != RT_ERROR_NONE) { if ((error == RT_ERROR_DRV_NO_RESOURCES) || (error == RT_ERROR_DRV_NO_STREAM_RESOURCES)) { - RT_LOG(RT_LOG_ERROR, "Failed to alloc stream id for auto split, retCode=%#x.", - static_cast(error)); + RT_LOG( + RT_LOG_ERROR, "Failed to alloc stream id for auto split, retCode=%#x.", static_cast(error)); return error; } - RT_LOG_INNER_MSG(RT_LOG_ERROR, "Failed to alloc stream id for auto split, retCode=%#x.", - static_cast(error)); + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Failed to alloc stream id for auto split, retCode=%#x.", static_cast(error)); return error; } error = AllocExecutedTimesSvm(); - ERROR_RETURN_MSG_INNER(error, "Failed to alloc svm for executed times, retCode=%#x.", - static_cast(error)); + ERROR_RETURN_MSG_INNER(error, "Failed to alloc svm for executed times, retCode=%#x.", static_cast(error)); SetSatMode(device_->GetSatMode()); @@ -1068,8 +1075,11 @@ rtError_t Stream::SetupForAutoSplit() BufferAllocator::OpenHugeBuff(); InitEmbeddedInnerHandle(this); - RT_LOG(RT_LOG_INFO, "stream setup for auto split end, master_stream_id=%d, cur_stream_id=%d, sq_id=%u, cq_id=%u, deviceId=%u, sqeBufferSize=%u", - GetExposedStreamId(), Id_(), sqId_, cqId_, device_->Id_(), sqeBufferSize_); + RT_LOG( + RT_LOG_INFO, + "stream setup for auto split end, master_stream_id=%d, cur_stream_id=%d, sq_id=%u, cq_id=%u, deviceId=%u, " + "sqeBufferSize=%u", + GetExposedStreamId(), Id_(), sqId_, cqId_, device_->Id_(), sqeBufferSize_); StreamStateCallbackManager::Instance().Notify(this, true); return RT_ERROR_NONE; @@ -1082,20 +1092,11 @@ void Stream::SetAbortStatus(rtError_t status) StreamUnLock(); } -rtError_t Stream::GetAbortStatus() const -{ - return abortStatus_; -} +rtError_t Stream::GetAbortStatus() const { return abortStatus_; } -void Stream::SetBeingAbortedFlag(bool abortFlag) -{ - isBeingAborted_ = abortFlag; -} +void Stream::SetBeingAbortedFlag(bool abortFlag) { isBeingAborted_ = abortFlag; } -bool Stream::GetBeingAbortedFlag() -{ - return isBeingAborted_; -} +bool Stream::GetBeingAbortedFlag() { return isBeingAborted_; } rtError_t Stream::TaskAbortAndQueryStatus(const uint32_t opType) { @@ -1106,23 +1107,26 @@ rtError_t Stream::TaskAbortAndQueryStatus(const uint32_t opType) do { // 3.send message to TS to abort sq ret = TaskAbortByType(result, opType, sqId_); - COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, - "Failed to abort stream, stream_id=%d, sq_id=%u, retCode=%#x.", - streamId_, sqId_, static_cast(ret)); + COND_RETURN_ERROR( + (ret != RT_ERROR_NONE), ret, "Failed to abort stream, stream_id=%d, sq_id=%u, retCode=%#x.", streamId_, + sqId_, static_cast(ret)); if (result == TS_SUCCESS) { break; } - COND_RETURN_ERROR_MSG_INNER((result == TS_ERROR_ILLEGAL_PARAM) || (result == TS_APP_EXIT_UNFINISHED) || - (result == TS_ERROR_ABORT_UNFINISHED), RT_ERROR_TSFW_ILLEGAL_PARAM, - "Failed to abort task by type, device_id=%u, stream_id=%d, sq_id=%u, result=%u.", - device_->Id_(), streamId_, sqId_, result); + COND_RETURN_ERROR_MSG_INNER( + (result == TS_ERROR_ILLEGAL_PARAM) || (result == TS_APP_EXIT_UNFINISHED) || + (result == TS_ERROR_ABORT_UNFINISHED), + RT_ERROR_TSFW_ILLEGAL_PARAM, + "Failed to abort task by type, device_id=%u, stream_id=%d, sq_id=%u, result=%u.", device_->Id_(), streamId_, + sqId_, result); count = ClockGetTimeIntervalUs(startTime); - COND_RETURN_ERROR_MSG_INNER((count >= ABORT_STREAM_TIMEOUT), RT_ERROR_WAIT_TIMEOUT, - "Abort process timeout, device_id=%u, stream_id=%d, time=%lu us, timeout_threshold=%lu us", - device_->Id_(), streamId_, count, ABORT_STREAM_TIMEOUT); + COND_RETURN_ERROR_MSG_INNER( + (count >= ABORT_STREAM_TIMEOUT), RT_ERROR_WAIT_TIMEOUT, + "Abort process timeout, device_id=%u, stream_id=%d, time=%lu us, timeout_threshold=%lu us", device_->Id_(), + streamId_, count, ABORT_STREAM_TIMEOUT); (void)mmSleep(1U); } while (result == TS_ERROR_APP_QUEUE_FULL); @@ -1130,21 +1134,23 @@ rtError_t Stream::TaskAbortAndQueryStatus(const uint32_t opType) do { // 4.polling if TS has aborted sq successfully until timeout ret = QueryAbortStatusByType(status, APP_ABORT_STS_QUERY_BY_SQ, sqId_); - COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, - "Query abort status failed, stream_id=%d, sq_id=%u, retCode=%#x.", - streamId_, sqId_, static_cast(ret)); + COND_RETURN_ERROR( + (ret != RT_ERROR_NONE), ret, "Query abort status failed, stream_id=%d, sq_id=%u, retCode=%#x.", streamId_, + sqId_, static_cast(ret)); if (status == DAVID_ABORT_TERMINATE_SUCC) { break; } - COND_RETURN_ERROR_MSG_INNER((status == DAVID_ABORT_TERMINATE_FAIL), RT_ERROR_TSFW_ILLEGAL_PARAM, + COND_RETURN_ERROR_MSG_INNER( + (status == DAVID_ABORT_TERMINATE_FAIL), RT_ERROR_TSFW_ILLEGAL_PARAM, "The abort status queried from the device is invalid, device_id=%u, stream_id=%d, sq_id=%u, status=%u.", device_->Id_(), streamId_, sqId_, status); count = ClockGetTimeIntervalUs(startTime); - COND_RETURN_ERROR_MSG_INNER((count >= ABORT_STREAM_TIMEOUT), RT_ERROR_WAIT_TIMEOUT, - "Query abort status timeout, device_id=%u, stream_id=%d, time=%lu us, timeout_threshold=%lu us.", + COND_RETURN_ERROR_MSG_INNER( + (count >= ABORT_STREAM_TIMEOUT), RT_ERROR_WAIT_TIMEOUT, + "Query abort status timeout, device_id=%u, stream_id=%d, time=%lu us, timeout_threshold=%lu us.", device_->Id_(), streamId_, count, ABORT_STREAM_TIMEOUT); (void)mmSleep(5U); } while (true); @@ -1155,16 +1161,18 @@ rtError_t Stream::TaskAbortAndQueryStatus(const uint32_t opType) rtError_t Stream::StreamStop() { if (device_->GetDeviceStatus() == RT_ERROR_DEVICE_TASK_ABORT) { - RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1018, "rtsStreamStop", - "The task on device " + std::to_string(device_->Id_()) + " is in abort state, stream_id=" - + std::to_string(streamId_) + ", sq_id=" + std::to_string(sqId_) + ", cq_id=" + std::to_string(cqId_)); + RT_LOG_OUTER_MSG_IMPL( + ErrorCode::EE1018, "rtsStreamStop", + "The task on device " + std::to_string(device_->Id_()) + " is in abort state, stream_id=" + + std::to_string(streamId_) + ", sq_id=" + std::to_string(sqId_) + ", cq_id=" + std::to_string(cqId_)); return RT_ERROR_STREAM_ABORT; } if (GetAbortStatus() == RT_ERROR_STREAM_ABORT) { - RT_LOG_OUTER_MSG_IMPL(ErrorCode::EE1018, "rtsStreamStop", - "The stream " + std::to_string(streamId_) + " is in abort state, sq_id=" - + std::to_string(sqId_) + ", cq_id=" + std::to_string(cqId_)); + RT_LOG_OUTER_MSG_IMPL( + ErrorCode::EE1018, "rtsStreamStop", + "The stream " + std::to_string(streamId_) + " is in abort state, sq_id=" + std::to_string(sqId_) + + ", cq_id=" + std::to_string(cqId_)); return RT_ERROR_STREAM_ABORT; } @@ -1174,20 +1182,17 @@ rtError_t Stream::StreamStop() // send message to TS to abort sq ret = TaskAbortAndQueryStatus(OP_STOP_STREAM); COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, "TaskStop retCode=%#x.", static_cast(ret)); - RT_LOG(RT_LOG_INFO, - "Finish StreamStop, stream_id=%d, sq_id=%u, cq_id=%u", - streamId_, sqId_, cqId_); + RT_LOG(RT_LOG_INFO, "Finish StreamStop, stream_id=%d, sq_id=%u, cq_id=%u", streamId_, sqId_, cqId_); return RT_ERROR_NONE; } rtError_t Stream::StreamAbort() { - RT_LOG(RT_LOG_INFO, "Enter StreamAbort, stream_id=%d, sq_id=%u, cq_id=%u", - streamId_, sqId_, cqId_); + RT_LOG(RT_LOG_INFO, "Enter StreamAbort, stream_id=%d, sq_id=%u, cq_id=%u", streamId_, sqId_, cqId_); if (device_->GetDeviceStatus() == RT_ERROR_DEVICE_TASK_ABORT) { - RT_LOG(RT_LOG_INFO, "device is in device abort status, stream_id=%d, sq_id=%u, cq_id=%u", - streamId_, sqId_, cqId_); + RT_LOG( + RT_LOG_INFO, "device is in device abort status, stream_id=%d, sq_id=%u, cq_id=%u", streamId_, sqId_, cqId_); return RT_ERROR_NONE; } @@ -1211,19 +1216,15 @@ rtError_t Stream::StreamAbort() // 4.recycle runtime task related resources ret = ResClear(ABORT_STREAM_TIMEOUT); COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, "ResClear retCode=%#x.", static_cast(ret)); - + // 5.clean up sq and cq in driver ret = SqCqUpdate(); COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, "SqCqUpdate retCode=%#x.", static_cast(ret)); - RT_LOG(RT_LOG_INFO, - "After sq cp update, stream_id=%d, sq_id=%u, cq_id=%u", - streamId_, sqId_, cqId_); - + RT_LOG(RT_LOG_INFO, "After sq cp update, stream_id=%d, sq_id=%u, cq_id=%u", streamId_, sqId_, cqId_); + // 6.restore stream normal state SetAbortStatus(RT_ERROR_NONE); - RT_LOG(RT_LOG_INFO, - "Finish StreamAbort, stream_id=%d, sq_id=%u, cq_id=%u", - streamId_, sqId_, cqId_); + RT_LOG(RT_LOG_INFO, "Finish StreamAbort, stream_id=%d, sq_id=%u, cq_id=%u", streamId_, sqId_, cqId_); return RT_ERROR_NONE; } @@ -1234,38 +1235,38 @@ rtError_t Stream::CleanSq() return error; } -rtError_t Stream::QuerySq(const uint32_t queryType, uint32_t &status) +rtError_t Stream::QuerySq(const uint32_t queryType, uint32_t& status) { - const rtError_t error = device_->Driver_()->QuerySq(device_->Id_(), device_->DevGetTsId(), sqId_, - queryType, status); + const rtError_t error = + device_->Driver_()->QuerySq(device_->Id_(), device_->DevGetTsId(), sqId_, queryType, status); return error; } -rtError_t Stream::TaskAbortByType(uint32_t &result, const uint32_t opType, const uint32_t targetId) +rtError_t Stream::TaskAbortByType(uint32_t& result, const uint32_t opType, const uint32_t targetId) { - const rtError_t error = device_->Driver_()->TaskAbortByType(device_->Id_(), device_->DevGetTsId(), opType, - targetId, result); + const rtError_t error = + device_->Driver_()->TaskAbortByType(device_->Id_(), device_->DevGetTsId(), opType, targetId, result); return error; } -rtError_t Stream::QueryAbortStatusByType(uint32_t &status, const uint32_t opType, const uint32_t targetId) +rtError_t Stream::QueryAbortStatusByType(uint32_t& status, const uint32_t opType, const uint32_t targetId) { - const rtError_t error = device_->Driver_()->QueryAbortStatusByType(device_->Id_(), device_->DevGetTsId(), - opType, targetId, status); + const rtError_t error = + device_->Driver_()->QueryAbortStatusByType(device_->Id_(), device_->DevGetTsId(), opType, targetId, status); return error; } -rtError_t Stream::RecoverAbortByType(const uint32_t opType, const uint32_t targetId, uint32_t &result) +rtError_t Stream::RecoverAbortByType(const uint32_t opType, const uint32_t targetId, uint32_t& result) { - const rtError_t error = device_->Driver_()->RecoverAbortByType(device_->Id_(), device_->DevGetTsId(), - opType, targetId, result); + const rtError_t error = + device_->Driver_()->RecoverAbortByType(device_->Id_(), device_->DevGetTsId(), opType, targetId, result); return error; } -rtError_t Stream::QueryRecoverStatusByType(uint32_t &status, const uint32_t opType, const uint32_t targetId) +rtError_t Stream::QueryRecoverStatusByType(uint32_t& status, const uint32_t opType, const uint32_t targetId) { - const rtError_t error = device_->Driver_()->QueryRecoverStatusByType(device_->Id_(), device_->DevGetTsId(), - opType, targetId, status); + const rtError_t error = + device_->Driver_()->QueryRecoverStatusByType(device_->Id_(), device_->DevGetTsId(), opType, targetId, status); return error; } @@ -1278,38 +1279,41 @@ rtError_t Stream::TaskKill(const uint32_t operationType) rtError_t Stream::SqCqUpdate() { /**** update sq cq id *****/ - const auto stmSqCqManage = const_cast(device_->GetStreamSqCqManage()); + const auto stmSqCqManage = const_cast(device_->GetStreamSqCqManage()); rtError_t error = stmSqCqManage->UpdateStreamSqCq(this); - ERROR_RETURN_MSG_INNER(error, "Failed to update sq/cq, deviceId=%u, streamId=%d, sqId=%u.", device_->Id_(), streamId_, sqId_); + ERROR_RETURN_MSG_INNER( + error, "Failed to update sq/cq, deviceId=%u, streamId=%d, sqId=%u.", device_->Id_(), streamId_, sqId_); if ((flags_ & RT_STREAM_CP_PROCESS_USE) == 0U) { uint32_t addrLen = 0U; - error = device_->Driver_()->GetSqRegVirtualAddrBySqid(static_cast(device_->Id_()), - device_->DevGetTsId(), sqId_, &sqRegVirtualAddr_, &addrLen); - ERROR_RETURN_MSG_INNER(error, "Failed to get sq reg virtual addr, deviceId=%u, sqId=%u.", device_->Id_(), sqId_); + error = device_->Driver_()->GetSqRegVirtualAddrBySqid( + static_cast(device_->Id_()), device_->DevGetTsId(), sqId_, &sqRegVirtualAddr_, &addrLen); + ERROR_RETURN_MSG_INNER( + error, "Failed to get sq reg virtual addr, deviceId=%u, sqId=%u.", device_->Id_(), sqId_); error = SetSqRegVirtualAddrToDevice(sqRegVirtualAddr_); - ERROR_RETURN_MSG_INNER(error, "Failed to copy virtual addr to device, sqId=%u, error=%#x.", sqId_, - static_cast(error)); + ERROR_RETURN_MSG_INNER( + error, "Failed to copy virtual addr to device, sqId=%u, error=%#x.", sqId_, static_cast(error)); } return error; } rtError_t Stream::ReAllocStreamId() { - rtError_t error = device_->Driver_()->ReAllocResourceId(device_->Id_(), device_->DevGetTsId(), priority_, - static_cast(streamId_), DRV_STREAM_ID); - ERROR_RETURN_MSG_INNER(error, "Realloc stream id failed, streamId=%d, deviceId=%u, ret=%d.", - streamId_, device_->Id_(), error); + rtError_t error = device_->Driver_()->ReAllocResourceId( + device_->Id_(), device_->DevGetTsId(), priority_, static_cast(streamId_), DRV_STREAM_ID); + ERROR_RETURN_MSG_INNER( + error, "Realloc stream id failed, streamId=%d, deviceId=%u, ret=%d.", streamId_, device_->Id_(), error); - StreamSqCqManage *stmSqCqManage = device_->GetStreamSqCqManage(); + StreamSqCqManage* stmSqCqManage = device_->GetStreamSqCqManage(); error = stmSqCqManage->ReAllocSqCqId(this); - ERROR_RETURN_MSG_INNER(error, "Realloc sqcq id failed, streamId=%d, deviceId=%u, sqId=%u, ret=%d.", - streamId_, device_->Id_(), sqId_, error); + ERROR_RETURN_MSG_INNER( + error, "Realloc sqcq id failed, streamId=%d, deviceId=%u, sqId=%u, ret=%d.", streamId_, device_->Id_(), sqId_, + error); uint32_t addrLen = 0U; - error = device_->Driver_()->GetSqRegVirtualAddrBySqid(static_cast(device_->Id_()), - device_->DevGetTsId(), sqId_, &sqRegVirtualAddr_, &addrLen); + error = device_->Driver_()->GetSqRegVirtualAddrBySqid( + static_cast(device_->Id_()), device_->DevGetTsId(), sqId_, &sqRegVirtualAddr_, &addrLen); ERROR_RETURN_MSG_INNER(error, "Failed to get sq reg virtual addr, deviceId=%u, sqId=%u.", device_->Id_(), sqId_); error = SetSqRegVirtualAddrToDevice(sqRegVirtualAddr_); @@ -1332,14 +1336,13 @@ rtError_t Stream::ReBuildDriverStreamResource() rtError_t Stream::Restore() { rtError_t error = ReAllocStreamId(); - ERROR_RETURN(error, "Realloc stream id failed, streamId=%d, deviceId=%u, ret=%d.", - streamId_, device_->Id_(), error); + ERROR_RETURN( + error, "Realloc stream id failed, streamId=%d, deviceId=%u, ret=%d.", streamId_, device_->Id_(), error); if (executedTimesSvm_ != nullptr) { error = device_->Driver_()->MemSetSync(executedTimesSvm_, sizeof(uint16_t), 0xFFU, sizeof(uint16_t)); - COND_RETURN_ERROR(error != RT_ERROR_NONE, - error, - "MemSetSync stream executed times SVM failed, retCode=%#x.", + COND_RETURN_ERROR( + error != RT_ERROR_NONE, error, "MemSetSync stream executed times SVM failed, retCode=%#x.", static_cast(error)); } return error; @@ -1351,39 +1354,43 @@ rtError_t Stream::SetL2Addr() // alloc device mem, max L2 size is 32M ,need 16 page table TIMESTAMP_BEGIN(rtStreamCreate_drvMemAllocHugePageManaged_drvMemAllocManaged_drvMemAdvise); rtError_t error = device_->Driver_()->DevMemAlloc(&pteVA_, memSize, RT_MEMORY_HBM, device_->Id_()); - ERROR_RETURN_MSG_INNER(error, "Failed to allocate device memory for L2 address, size=%lu, device_id=%u, retCode=%#x.", - memSize, device_->Id_(), error); + ERROR_RETURN_MSG_INNER( + error, "Failed to allocate device memory for L2 address, size=%lu, device_id=%u, retCode=%#x.", memSize, + device_->Id_(), error); TIMESTAMP_END(rtStreamCreate_drvMemAllocHugePageManaged_drvMemAllocManaged_drvMemAdvise); // cpy pte to device mem TIMESTAMP_BEGIN(rtStreamCreate_drvMemcpy); - error = device_->Driver_()->MemCopySync(pteVA_, memSize, static_cast(pte_.data()), - memSize, RT_MEMCPY_HOST_TO_DEVICE); - ERROR_GOTO(error, DEV_FREE, "Failed to memcpy for L2 address, retCode=%#x," - "srcSize=%zu(bytes), dstSize=%zu(bytes).", static_cast(error), memSize, memSize); + error = device_->Driver_()->MemCopySync( + pteVA_, memSize, static_cast(pte_.data()), memSize, RT_MEMCPY_HOST_TO_DEVICE); + ERROR_GOTO( + error, DEV_FREE, + "Failed to memcpy for L2 address, retCode=%#x," + "srcSize=%zu(bytes), dstSize=%zu(bytes).", + static_cast(error), memSize, memSize); TIMESTAMP_END(rtStreamCreate_drvMemcpy); return RT_ERROR_NONE; DEV_FREE: const rtError_t errorDevFree = device_->Driver_()->DevMemFree(pteVA_, device_->Id_()); - COND_LOG(errorDevFree != RT_ERROR_NONE, "dump dev mem free failed, retCode=%#x, deviceId=%u.", - errorDevFree, device_->Id_()); + COND_LOG( + errorDevFree != RT_ERROR_NONE, "dump dev mem free failed, retCode=%#x, deviceId=%u.", errorDevFree, + device_->Id_()); pteVA_ = nullptr; return error; } -rtError_t Stream::ProcL2AddrTask(TaskInfo *&tsk) +rtError_t Stream::ProcL2AddrTask(TaskInfo*& tsk) { // trans device va to pte_pa; uint64_t ptePA; int32_t devId = static_cast(device_->Id_()); - rtError_t error = device_->Driver_()->MemAddressTranslate(devId, - RtPtrToValue(pteVA_), &ptePA); - ERROR_RETURN(error, "Failed to translate address to physic for L2 address, retCode=%#x.", - static_cast(error)); + rtError_t error = device_->Driver_()->MemAddressTranslate(devId, RtPtrToValue(pteVA_), &ptePA); + ERROR_RETURN( + error, "Failed to translate address to physic for L2 address, retCode=%#x.", static_cast(error)); rtError_t errorReason; - TaskInfo *l2Task = AllocTask(tsk, TS_TASK_TYPE_CREATE_L2_ADDR, errorReason); + TaskInfo* l2Task = AllocTask(tsk, TS_TASK_TYPE_CREATE_L2_ADDR, errorReason); NULL_PTR_RETURN_MSG(l2Task, errorReason); error = CreateL2AddrTaskInit(l2Task, ptePA); @@ -1395,16 +1402,18 @@ rtError_t Stream::SubmitCreateStreamTask() { TaskInfo submitTask = {}; rtError_t errorReason; - TaskInfo *createStmTsk = AllocTask(&submitTask, TS_TASK_TYPE_CREATE_STREAM, errorReason); + TaskInfo* createStmTsk = AllocTask(&submitTask, TS_TASK_TYPE_CREATE_STREAM, errorReason); NULL_PTR_RETURN_MSG(createStmTsk, errorReason); rtError_t error = CreateStreamTaskInit(createStmTsk, flags_); - ERROR_GOTO_MSG_INNER(error, ERROR_TASK, "Failed to init task, task_id=%hu, stream_id=%d, retCode=%#x.", - submitTask.id, streamId_, error); + ERROR_GOTO_MSG_INNER( + error, ERROR_TASK, "Failed to init task, task_id=%hu, stream_id=%d, retCode=%#x.", submitTask.id, streamId_, + error); error = device_->SubmitTask(createStmTsk); - ERROR_GOTO_MSG_INNER(error, ERROR_TASK, "Failed to submit task, task_id=%hu, stream_id=%d, retCode=%#x.", - submitTask.id, streamId_, error); + ERROR_GOTO_MSG_INNER( + error, ERROR_TASK, "Failed to submit task, task_id=%hu, stream_id=%d, retCode=%#x.", submitTask.id, streamId_, + error); return RT_ERROR_NONE; ERROR_TASK: @@ -1412,10 +1421,10 @@ ERROR_TASK: return error; } -rtError_t Stream::SubmitStreamRecycle(Stream* exeStream, bool isForceRecycle, uint16_t logicCqId, TaskInfo *&task) const +rtError_t Stream::SubmitStreamRecycle(Stream* exeStream, bool isForceRecycle, uint16_t logicCqId, TaskInfo*& task) const { TaskInfo submitRecycleTask = {}; - TaskInfo *maintenanceTsk = nullptr; + TaskInfo* maintenanceTsk = nullptr; rtError_t errorReason; if (this != exeStream && device_->IsSupportFeature(RtOptionalFeatureType::RT_FEATURE_DEVICE_CTRL_SQ)) { RtMaintainceParam param = {streamId_, isForceRecycle, logicCqId}; @@ -1432,20 +1441,21 @@ rtError_t Stream::SubmitStreamRecycle(Stream* exeStream, bool isForceRecycle, ui rtError_t error = device_->SubmitTask(maintenanceTsk); if (error != RT_ERROR_NONE) { (void)device_->GetTaskFactory()->Recycle(maintenanceTsk); - RT_LOG_INNER_MSG(RT_LOG_ERROR, "Failed to submit task, stream_id=%d, task_id=%u, retCode=%#x.", - streamId_, static_cast(maintenanceTsk->id), error); + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Failed to submit task, stream_id=%d, task_id=%u, retCode=%#x.", streamId_, + static_cast(maintenanceTsk->id), error); } return error; } rtError_t Stream::TearDown(const bool terminal, bool flag) { - Runtime * const rt = Runtime::Instance(); + Runtime* const rt = Runtime::Instance(); TaskInfo submitDestroyTask = {}; - TaskInfo *tsk = nullptr; - TaskInfo *recycleTask = nullptr; + TaskInfo* tsk = nullptr; + TaskInfo* recycleTask = nullptr; Stream* exeStream = this; - Device * const dev = device_; + Device* const dev = device_; const int32_t stmId = streamId_; uint32_t logicCqId = 0U; uint32_t tskForceRecycleCnt = 0; @@ -1469,14 +1479,16 @@ rtError_t Stream::TearDown(const bool terminal, bool flag) const bool starsFlag = dev->IsStarsPlatform(); if (rt->GetDisableThread() && (!starsFlag)) { bool isFastCq = false; - error = dev->GetStreamSqCqManage()->AllocLogicCq(static_cast(stmId), - IsSteamNeedFastCq(), logicCqId, isFastCq); + error = dev->GetStreamSqCqManage()->AllocLogicCq( + static_cast(stmId), IsSteamNeedFastCq(), logicCqId, isFastCq); COND_RETURN_ERROR(error != RT_ERROR_NONE, error, "Alloc logic cq failed."); - RT_LOG(RT_LOG_DEBUG, "stream teardown. stream_id=%d, logic_cq_id=%u, is_Fast_Cq=%u", - stmId, logicCqId, static_cast(isFastCq)); + RT_LOG( + RT_LOG_DEBUG, "stream teardown. stream_id=%d, logic_cq_id=%u, is_Fast_Cq=%u", stmId, logicCqId, + static_cast(isFastCq)); } bool isForceRecycle = GetForceRecycleFlag(flag); - RT_LOG(RT_LOG_INFO, "stream_id=%d, sqId=%u, pendingNum=%u, isForceRecycle_=%d, flag=%d, failMode=%u.", stmId, sqId_, + RT_LOG( + RT_LOG_INFO, "stream_id=%d, sqId=%u, pendingNum=%u, isForceRecycle_=%d, flag=%d, failMode=%u.", stmId, sqId_, pendingNum_.Value(), isForceRecycle, flag, GetFailureMode()); if (isForceRecycle) { // force recycle may use ctrlsq @@ -1509,31 +1521,42 @@ rtError_t Stream::TearDown(const bool terminal, bool flag) } if (starsFlag) { error = dev->Driver_()->GetSqHead(devId, tsId, sqId_, sqHead); - ERROR_GOTO_MSG_INNER(error, ERROR_FREE, "Get sq head failed, stream_id=%d, sqId=%u, pendingNum=%u, " - "isForceRecycle_=%d.", stmId, sqId_, pendingNum_.Value(), isForceRecycle_); + ERROR_GOTO_MSG_INNER( + error, ERROR_FREE, + "Get sq head failed, stream_id=%d, sqId=%u, pendingNum=%u, " + "isForceRecycle_=%d.", + stmId, sqId_, pendingNum_.Value(), isForceRecycle_); error = dev->Driver_()->GetSqTail(devId, tsId, sqId_, sqTail); - ERROR_GOTO_MSG_INNER(error, ERROR_FREE, "Get sq tail failed, stream_id=%d, sqId=%u, pendingNum=%u, " - "isForceRecycle_=%d.", stmId, sqId_, pendingNum_.Value(), isForceRecycle_); - - RT_LOG(RT_LOG_INFO, "submitTaskFail=%d, stream_id=%d, sqHead=%u, sqTail=%u, tryWaitCnt=%u, pendingNum=%u", + ERROR_GOTO_MSG_INNER( + error, ERROR_FREE, + "Get sq tail failed, stream_id=%d, sqId=%u, pendingNum=%u, " + "isForceRecycle_=%d.", + stmId, sqId_, pendingNum_.Value(), isForceRecycle_); + + RT_LOG( + RT_LOG_INFO, "submitTaskFail=%d, stream_id=%d, sqHead=%u, sqTail=%u, tryWaitCnt=%u, pendingNum=%u", isSubmitTaskFail_, stmId, sqHead, sqTail, tryWaitCnt, pendingNum_.Value()); constexpr uint32_t maxWaitCnt = 6U; if ((isSubmitTaskFail_) && (waitCnt > maxWaitCnt)) { break; } error = dev->Driver_()->GetSqEnable(devId, tsId, sqId_, sqEnable); - ERROR_GOTO_MSG_INNER(error, ERROR_FREE, "Get sq enable failed, stream_id=%d, sqId=%u, pendingNum=%u, " - "isForceRecycle_=%d.", stmId, sqId_, pendingNum_.Value(), isForceRecycle_); + ERROR_GOTO_MSG_INNER( + error, ERROR_FREE, + "Get sq enable failed, stream_id=%d, sqId=%u, pendingNum=%u, " + "isForceRecycle_=%d.", + stmId, sqId_, pendingNum_.Value(), isForceRecycle_); // Wait sqHead == sqTail in 30s constexpr uint32_t waitTimeout = 3000U; // dvpp需要等待response状态返回才拉低Sq，同时head=tail， 其他的场景当sq是disable的时候需要直接回收。 if ((sqHead == sqTail) || (tryWaitCnt > waitTimeout) || !sqEnable) { uint32_t reclaimTaskId = UINT32_MAX; - RT_LOG(RT_LOG_INFO, "stream_id=%d, sqId_=%u, pendingNum=%u, isForceRecycle_=%d, isSubmitTaskFail_=%d.", + RT_LOG( + RT_LOG_INFO, "stream_id=%d, sqId_=%u, pendingNum=%u, isForceRecycle_=%d, isSubmitTaskFail_=%d.", stmId, sqId_, pendingNum_.Value(), isForceRecycle_, isSubmitTaskFail_); - + if (IsSeparateSendAndRecycle()) { StreamRecycleLock(); dev->RecycleSeparatedStmByFinishedId(this, static_cast(lastTaskId_)); @@ -1566,7 +1589,7 @@ rtError_t Stream::TearDown(const bool terminal, bool flag) RT_LOG(RT_LOG_INFO, "stream_id=%d, delay recycle task num=%zu.", stmId, delayRecycleTaskid_.size()); if (!delayRecycleTaskid_.empty()) { - Profiler * const profilerPtr = Runtime::Instance()->Profiler_(); + Profiler* const profilerPtr = Runtime::Instance()->Profiler_(); if (profilerPtr != nullptr) { profilerPtr->EraseStream(this); } @@ -1576,8 +1599,9 @@ rtError_t Stream::TearDown(const bool terminal, bool flag) const uint16_t taskId = delayRecycleTaskid_.back(); recycleTask = dev->GetTaskFactory()->GetTask(stmId, taskId); if (recycleTask == nullptr) { - RT_LOG(RT_LOG_WARNING, "Cannot find task from the factory, stream_id=%d task_id=%u", - stmId, static_cast(taskId)); + RT_LOG( + RT_LOG_WARNING, "Cannot find task from the factory, stream_id=%d task_id=%u", stmId, + static_cast(taskId)); delayRecycleTaskid_.pop_back(); continue; } @@ -1587,8 +1611,8 @@ rtError_t Stream::TearDown(const bool terminal, bool flag) if (GetSubscribeFlag() != StreamSubscribeFlag::SUBSCRIBE_NONE) { error = rt->UnSubscribeReport(this); - ERROR_RETURN_MSG_INNER(error, "Failed to unsubscribe streamId(%d), retCode=%#x.", stmId, - static_cast(error)); + ERROR_RETURN_MSG_INNER( + error, "Failed to unsubscribe streamId(%d), retCode=%#x.", stmId, static_cast(error)); } (void)SendFlipTaskWithStreamId(this); @@ -1600,8 +1624,9 @@ rtError_t Stream::TearDown(const bool terminal, bool flag) return error; } exeStream = this; - if ((GetFailureMode() == ABORT_ON_FAILURE) || ((exeStream->Context_() != nullptr) && - (exeStream->Context_()->GetFailureError() != RT_ERROR_NONE) && (dev->PrimaryStream_()->Id_() != stmId))) { + if ((GetFailureMode() == ABORT_ON_FAILURE) || + ((exeStream->Context_() != nullptr) && (exeStream->Context_()->GetFailureError() != RT_ERROR_NONE) && + (dev->PrimaryStream_()->Id_() != stmId))) { // stream is abort, only ctrl sq can destroy stream. exeStream = dev->GetCtrlStream(this); } @@ -1611,16 +1636,17 @@ rtError_t Stream::TearDown(const bool terminal, bool flag) error = MaintenanceTaskInit(tsk, MT_STREAM_DESTROY, static_cast(stmId), false); tsk->u.maintenanceTaskInfo.waitCqId = static_cast(logicCqId); - ERROR_GOTO_MSG_INNER(error, ERROR_FREE, "Failed to init maintenance task, retCode=%#x.", static_cast(error)); + ERROR_GOTO_MSG_INNER( + error, ERROR_FREE, "Failed to init maintenance task, retCode=%#x.", static_cast(error)); if (terminal) { tsk->terminal = true; } error = dev->SubmitTask(tsk); - ERROR_GOTO_MSG_INNER(error, ERROR_FREE, - "Failed to submit maintenance task, retCode=%#x, stream_id=%d, task_id=%u.", static_cast(error), stmId, - static_cast(tsk->id)); + ERROR_GOTO_MSG_INNER( + error, ERROR_FREE, "Failed to submit maintenance task, retCode=%#x, stream_id=%d, task_id=%u.", + static_cast(error), stmId, static_cast(tsk->id)); // MT task sent by ctrlsq, taskid in stream will be recycled here, otherwise recycled in Recycle(tsk) if (Runtime::Instance()->GetDisableThread()) { FreePersistentTaskID(exeStream); @@ -1635,11 +1661,11 @@ ERROR_FREE: return error; } -rtError_t Stream::RecycleTaskWithCtrlsq(Device * const dev, const uint32_t logicCqId, const uint32_t recycleCnt) +rtError_t Stream::RecycleTaskWithCtrlsq(Device* const dev, const uint32_t logicCqId, const uint32_t recycleCnt) { // use ctrl sq to force recycle task in stream. rtError_t error = RT_ERROR_NONE; - TaskInfo *tsk = nullptr; + TaskInfo* tsk = nullptr; NULL_PTR_RETURN(dev, RT_ERROR_DEVICE_NULL); NULL_PTR_RETURN(dev->CtrlStream_(), RT_ERROR_STREAM_NULL); @@ -1650,21 +1676,18 @@ rtError_t Stream::RecycleTaskWithCtrlsq(Device * const dev, const uint32_t logic error = RT_ERROR_TASK_NEW; tsk = dev->GetTaskFactory()->Alloc(exeStream, TS_TASK_TYPE_MAINTENANCE, error); NULL_PTR_RETURN_MSG(tsk, error); - std::function const mtTaskRecycle = [&dev, &tsk]() { - (void)dev->GetTaskFactory()->Recycle(tsk); - }; + std::function const mtTaskRecycle = [&dev, &tsk]() { (void)dev->GetTaskFactory()->Recycle(tsk); }; ScopeGuard taskGuard(mtTaskRecycle); error = MaintenanceTaskInit(tsk, MT_STREAM_RECYCLE_TASK, static_cast(streamId_), true); - ERROR_RETURN_MSG_INNER(error, "Failed to init maintenance task, retCode=%#x, stream_id=%d.", - error, streamId_); + ERROR_RETURN_MSG_INNER(error, "Failed to init maintenance task, retCode=%#x, stream_id=%d.", error, streamId_); tsk->u.maintenanceTaskInfo.waitCqId = static_cast(logicCqId); - RT_LOG(RT_LOG_INFO, "ctrlsq=%d alloc MT task_id=%u for stream_id=%d with pendingNum=%d to force recycle task", + RT_LOG( + RT_LOG_INFO, "ctrlsq=%d alloc MT task_id=%u for stream_id=%d with pendingNum=%d to force recycle task", exeStream->streamId_, tsk->id, streamId_, pendingNum_.Value()); error = dev->SubmitTask(tsk); - ERROR_RETURN_MSG_INNER(error, "Failed to submit maintenance task, retCode=%#x, stream_id=%d.", - error, streamId_); + ERROR_RETURN_MSG_INNER(error, "Failed to submit maintenance task, retCode=%#x, stream_id=%d.", error, streamId_); taskGuard.ReleaseGuard(); uint32_t reclaimTaskId = UINT32_MAX; @@ -1674,10 +1697,7 @@ rtError_t Stream::RecycleTaskWithCtrlsq(Device * const dev, const uint32_t logic return error; } -rtError_t Stream::WaitEvent(Event * const evt, const uint32_t timeout) -{ - return evt->Wait(this, timeout); -} +rtError_t Stream::WaitEvent(Event* const evt, const uint32_t timeout) { return evt->Wait(this, timeout); } rtError_t Stream::ProcessDrvErr(void) { @@ -1691,7 +1711,7 @@ rtError_t Stream::ProcessDrvErr(void) } // report error message error const std::lock_guard errLock(errorMsgLock_); - for (const auto &errMsg : errorMsg_) { + for (const auto& errMsg : errorMsg_) { RT_LOG_CALL_MSG(errMsg.first, "%s", errMsg.second.c_str()); } return error; @@ -1722,13 +1742,13 @@ rtError_t Stream::GetError(void) } const uint32_t tmpErrCode = GetErrCode(); if (tmpErrCode != static_cast(RT_ERROR_NONE)) { - if (tmpErrCode == static_cast(TS_ERROR_END_OF_SEQUENCE)) { + if (tmpErrCode == static_cast(TS_ERROR_END_OF_SEQUENCE)) { error = RT_ERROR_END_OF_SEQUENCE; - } else if (tmpErrCode == static_cast(TS_MODEL_ABORT_NORMAL)) { + } else if (tmpErrCode == static_cast(TS_MODEL_ABORT_NORMAL)) { error = RT_ERROR_MODEL_ABORT_NORMAL; - } else if (tmpErrCode == static_cast(TS_ERROR_AICORE_OVERFLOW)) { + } else if (tmpErrCode == static_cast(TS_ERROR_AICORE_OVERFLOW)) { error = RT_ERROR_TSFW_AICORE_OVER_FLOW_FAIL; - } else if (tmpErrCode == static_cast(TS_ERROR_AIVEC_OVERFLOW)) { + } else if (tmpErrCode == static_cast(TS_ERROR_AIVEC_OVERFLOW)) { error = RT_ERROR_TSFW_AIVEC_OVER_FLOW_FAIL; } else if (tmpErrCode == static_cast(TS_ERROR_AICPU_OVERFLOW)) { error = RT_ERROR_TSFW_AICPU_OVER_FLOW_FAIL; @@ -1739,10 +1759,11 @@ rtError_t Stream::GetError(void) } else if (tmpErrCode == static_cast(TS_ERROR_AICPU_TIMEOUT)) { error = RT_ERROR_TSFW_AICPU_TIMEOUT; } else { - RT_LOG(RT_LOG_ERROR, "Stream Synchronize failed, stream_id=%d, retCode=%#x, [%s].", - streamId_, tmpErrCode, GetTsErrCodeMap(tmpErrCode, &error)); + RT_LOG( + RT_LOG_ERROR, "Stream Synchronize failed, stream_id=%d, retCode=%#x, [%s].", streamId_, tmpErrCode, + GetTsErrCodeMap(tmpErrCode, &error)); const std::lock_guard errLock(errorMsgLock_); - for (const auto &errMsg : errorMsg_) { + for (const auto& errMsg : errorMsg_) { RT_LOG_CALL_MSG(errMsg.first, "%s", errMsg.second.c_str()); } errorMsg_.clear(); @@ -1769,12 +1790,13 @@ rtError_t Stream::CheckContextStatus(const bool isBlockDefaultStream) const if (device_ != nullptr) { (void)device_->GetDevRunningState(); rtError_t status = device_->GetDevStatus(); - COND_PROC_RETURN_ERROR_MSG_CALL(ERR_MODULE_DRV, status != RT_ERROR_NONE, status, - RT_LOG_INNER_DETAIL_MSG(RT_DRV_INNER_ERROR, {"device_id"}, {std::to_string(device_->Id_())});, - "Device %u is faulty, ret=%#x.", device_->Id_(), status); + COND_PROC_RETURN_ERROR_MSG_CALL( + ERR_MODULE_DRV, status != RT_ERROR_NONE, status, + RT_LOG_INNER_DETAIL_MSG(RT_DRV_INNER_ERROR, {"device_id"}, {std::to_string(device_->Id_())}); + , "Device %u is faulty, ret=%#x.", device_->Id_(), status); status = device_->GetDeviceStatus(); - COND_RETURN_ERROR_MSG_INNER(status != RT_ERROR_NONE, status, "Device %u is faulty, status=%d.", - device_->Id_(), status); + COND_RETURN_ERROR_MSG_INNER( + status != RT_ERROR_NONE, status, "Device %u is faulty, status=%d.", device_->Id_(), status); } return RT_ERROR_NONE; } else { @@ -1782,18 +1804,19 @@ rtError_t Stream::CheckContextStatus(const bool isBlockDefaultStream) const } } -rtError_t Stream::CheckContextTaskSend(const TaskInfo * const workTask) const +rtError_t Stream::CheckContextTaskSend(const TaskInfo* const workTask) const { if (context_ == nullptr) { if (device_ != nullptr) { (void)device_->GetDevRunningState(); rtError_t status = device_->GetDevStatus(); - COND_PROC_RETURN_ERROR_MSG_CALL(ERR_MODULE_DRV, status != RT_ERROR_NONE, status, - RT_LOG_INNER_DETAIL_MSG(RT_DRV_INNER_ERROR, {"device_id"}, {std::to_string(device_->Id_())});, - "Device %u is faulty, ret=%#x.", device_->Id_(), status); + COND_PROC_RETURN_ERROR_MSG_CALL( + ERR_MODULE_DRV, status != RT_ERROR_NONE, status, + RT_LOG_INNER_DETAIL_MSG(RT_DRV_INNER_ERROR, {"device_id"}, {std::to_string(device_->Id_())}); + , "Device %u is faulty, ret=%#x.", device_->Id_(), status); status = device_->GetDeviceStatus(); - COND_RETURN_ERROR_MSG_INNER(status != RT_ERROR_NONE, status, "Device %u is faulty, status=%d.", - device_->Id_(), status); + COND_RETURN_ERROR_MSG_INNER( + status != RT_ERROR_NONE, status, "Device %u is faulty, status=%d.", device_->Id_(), status); } return RT_ERROR_NONE; } else { @@ -1801,7 +1824,7 @@ rtError_t Stream::CheckContextTaskSend(const TaskInfo * const workTask) const } } -rtError_t Stream::GetFinishedTaskIdBySqHead(uint16_t &sqHead, uint32_t &finishedId) +rtError_t Stream::GetFinishedTaskIdBySqHead(uint16_t& sqHead, uint32_t& finishedId) { // sqHead indicates the current position of execution; it has not yet been completed. const uint32_t rtsqDepth = @@ -1836,8 +1859,9 @@ rtError_t Stream::GetFinishedTaskIdBySqHead(uint16_t &sqHead, uint32_t &finished if ((endTaskId != MAX_UINT16_NUM) && TASK_ID_GT(endTaskId, lastId)) { return RT_ERROR_NONE; } - RT_LOG(RT_LOG_INFO, "stream_id=%d, sq_id=%u, sqHead=%u, nextTaskId=%u, finishedPos=%u, endTaskId=%u", - streamId_, sqId_, sqHead, nextTaskId, finishedPos, endTaskId); + RT_LOG( + RT_LOG_INFO, "stream_id=%d, sq_id=%u, sqHead=%u, nextTaskId=%u, finishedPos=%u, endTaskId=%u", streamId_, sqId_, + sqHead, nextTaskId, finishedPos, endTaskId); // In scenarios with multiple SQEs, ffts+, mem wait, determine whether a task has been completed. // If the task IDs before and after are the same, it is considered that the task has not been completed. @@ -1878,7 +1902,7 @@ bool Stream::SynchronizeDelayTime(const uint16_t finishedId, const uint16_t task return false; } -rtError_t Stream::SynchronizeExecutedTask(const uint32_t taskId, const mmTimespec &beginTime, int32_t timeout) +rtError_t Stream::SynchronizeExecutedTask(const uint32_t taskId, const mmTimespec& beginTime, int32_t timeout) { uint16_t sqHead = static_cast(MAX_UINT16_NUM); rtError_t error = RT_ERROR_NONE; @@ -1888,13 +1912,17 @@ rtError_t Stream::SynchronizeExecutedTask(const uint32_t taskId, const mmTimespe int32_t syncTimes = 0; const uint32_t posTail = GetTaskPosTail(); while (true) { - COND_PROC_RETURN_ERROR_MSG_INNER((IsProcessTimeout(beginTime, timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, this->SetNeedSyncFlag(true);, - "Stream synchronize timeout, device_id=%u, stream_id=%d, timeout=%dms.", - device_->Id_(), streamId_, timeout); + COND_PROC_RETURN_ERROR_MSG_INNER( + (IsProcessTimeout(beginTime, timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, this->SetNeedSyncFlag(true); + , "Stream synchronize timeout, device_id=%u, stream_id=%d, timeout=%dms.", device_->Id_(), streamId_, + timeout); if (IsProcessTimeout(beginTime, reportTime)) { reportTime += REPORT_TIME_UINT; - RT_LOG(RT_LOG_EVENT, "report three minutes timeout! stream_id=%d, sq_id=%u, task_id=%u, sqHead=%u, flip_num=%u, pendingNum=%u.", Id_(), GetSqId(), taskId, sqHead, - GetTaskIdFlipNum(), GetPendingNum()); + RT_LOG( + RT_LOG_EVENT, + "report three minutes timeout! stream_id=%d, sq_id=%u, task_id=%u, sqHead=%u, flip_num=%u, " + "pendingNum=%u.", + Id_(), GetSqId(), taskId, sqHead, GetTaskIdFlipNum(), GetPendingNum()); if (Runtime::Instance()->excptCallBack_ != nullptr) { Runtime::Instance()->excptCallBack_(RT_EXCEPTION_TASK_TIMEOUT); } @@ -1904,8 +1932,10 @@ rtError_t Stream::SynchronizeExecutedTask(const uint32_t taskId, const mmTimespe "The stream is in abort state, stream_id=%u.", streamId_); error = CheckContextStatus(false); COND_RETURN_ERROR(error != RT_ERROR_NONE, error, "Context is abort, status=%#x.", static_cast(error)); - COND_RETURN_ERROR_MSG_INNER((GetStreamStatus() != StreamStatus::NORMAL), RT_ERROR_STREAM_SYNC, - "The stream status is %u (NORMAL=0, ABNORMAL=1), device_id=%u, stream_id=%d.", static_cast(GetStreamStatus()), device_->Id_(), Id_()); + COND_RETURN_ERROR_MSG_INNER( + (GetStreamStatus() != StreamStatus::NORMAL), RT_ERROR_STREAM_SYNC, + "The stream status is %u (NORMAL=0, ABNORMAL=1), device_id=%u, stream_id=%d.", + static_cast(GetStreamStatus()), device_->Id_(), Id_()); const uint16_t exeEndTaskId = GetExecuteEndTaskId(); if (((exeEndTaskId != MAX_UINT16_NUM) && IsTaskExcuted(exeEndTaskId, taskId)) || (sqHead == posTail)) { return RT_ERROR_NONE; @@ -1928,30 +1958,33 @@ rtError_t Stream::SynchronizeExecutedTask(const uint32_t taskId, const mmTimespe } } -rtError_t Stream::WaitConcernedTaskRecycled(const uint16_t taskId, const mmTimespec &beginTime, int32_t timeout) +rtError_t Stream::WaitConcernedTaskRecycled(const uint16_t taskId, const mmTimespec& beginTime, int32_t timeout) { uint32_t tryCount = 0U; rtError_t error = RT_ERROR_NONE; constexpr uint16_t perSchedYield = 1000U; RT_LOG(RT_LOG_DEBUG, "stream_id=%u, task_id=%u, recycleEndTaskId_=%u.", Id_(), taskId, recycleEndTaskId_.Value()); - while (true) { - COND_RETURN_ERROR_MSG_INNER((IsProcessTimeout(beginTime, timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, - "Task reclaim timeout, device_id=%u, stream_id=%d, timeout=%dms, tryCount=%u.", - device_->Id_(), streamId_, timeout, tryCount); - COND_RETURN_ERROR_MSG_INNER((abortStatus_ == RT_ERROR_STREAM_ABORT), RT_ERROR_STREAM_ABORT, "The stream %u is in abort state.", streamId_); - error = CheckContextStatus(false); - COND_RETURN_ERROR(error != RT_ERROR_NONE, error, "context is abort, status=%#x.", static_cast(error)); - if (IsTaskExcuted(recycleEndTaskId_.Value(), taskId)) { - return RT_ERROR_NONE; - } - if (!device_->GetIsDoingRecycling()) { - device_->WakeUpRecycleThread(); - } - tryCount++; - if (tryCount % perSchedYield == 0) { - std::this_thread::yield(); - } - } + while (true) { + COND_RETURN_ERROR_MSG_INNER( + (IsProcessTimeout(beginTime, timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, + "Task reclaim timeout, device_id=%u, stream_id=%d, timeout=%dms, tryCount=%u.", device_->Id_(), streamId_, + timeout, tryCount); + COND_RETURN_ERROR_MSG_INNER( + (abortStatus_ == RT_ERROR_STREAM_ABORT), RT_ERROR_STREAM_ABORT, "The stream %u is in abort state.", + streamId_); + error = CheckContextStatus(false); + COND_RETURN_ERROR(error != RT_ERROR_NONE, error, "context is abort, status=%#x.", static_cast(error)); + if (IsTaskExcuted(recycleEndTaskId_.Value(), taskId)) { + return RT_ERROR_NONE; + } + if (!device_->GetIsDoingRecycling()) { + device_->WakeUpRecycleThread(); + } + tryCount++; + if (tryCount % perSchedYield == 0) { + std::this_thread::yield(); + } + } } rtError_t Stream::SynchronizeImpl(const uint32_t syncTaskId, const uint16_t concernedTaskId, int32_t timeout) @@ -1963,14 +1996,17 @@ rtError_t Stream::SynchronizeImpl(const uint32_t syncTaskId, const uint16_t conc StreamSyncFinishReport(); if (concernedTaskId == MAX_UINT16_NUM) { device_->WakeUpRecycleThread(); - RT_LOG(RT_LOG_INFO, "device_id=%d, stream_id=%d, task_id=%u has been completed, no concerned cqe.", - device_->Id_(), streamId_, syncTaskId); + RT_LOG( + RT_LOG_INFO, "device_id=%d, stream_id=%d, task_id=%u has been completed, no concerned cqe.", device_->Id_(), + streamId_, syncTaskId); return error; } error = WaitConcernedTaskRecycled(concernedTaskId, beginTime, timeout); COND_RETURN_ERROR((error != RT_ERROR_NONE), error, "failed, stream_id=%d, error=0x%x", Id_(), error); - RT_LOG(RT_LOG_INFO, "device_id=%d, stream_id=%d, task_id=%u has been completed, concerned task_id=%u has been recycled.", - device_->Id_(), streamId_, syncTaskId, concernedTaskId); + RT_LOG( + RT_LOG_INFO, + "device_id=%d, stream_id=%d, task_id=%u has been completed, concerned task_id=%u has been recycled.", + device_->Id_(), streamId_, syncTaskId, concernedTaskId); return error; } @@ -1995,10 +2031,10 @@ rtError_t Stream::Synchronize(const bool isNeedWaitSyncCq, int32_t timeout) error = WaitForTask(lastTaskId_, isNeedWaitSyncCq, timeout); return GetSynchronizeError(error); } - COND_RETURN_ERROR_MSG_INNER((GetFailureMode() == ABORT_ON_FAILURE), GetError(), - "The stream %u is in abort state.", Id_()); + COND_RETURN_ERROR_MSG_INNER( + (GetFailureMode() == ABORT_ON_FAILURE), GetError(), "The stream %u is in abort state.", Id_()); - Event *event = new (std::nothrow) Event(device_, RT_EVENT_DEFAULT, Context_(), true); + Event* event = new (std::nothrow) Event(device_, RT_EVENT_DEFAULT, Context_(), true); COND_RETURN_AND_MSG_OUTER(event == nullptr, RT_ERROR_EVENT_NEW, ErrorCode::EE1013, sizeof(Event), "new"); uint32_t tryCount = 50U; @@ -2033,7 +2069,7 @@ ERROR_FREE: void Stream::StreamSyncFinishReport() const { - Profiler * const profilerPtr = Runtime::Instance()->Profiler_(); + Profiler* const profilerPtr = Runtime::Instance()->Profiler_(); if (profilerPtr != nullptr) { profilerPtr->ReportStreamSynctaskFinish(RT_PROF_API_STREAM_SYNC_TASK_FINISH); } @@ -2051,24 +2087,30 @@ rtError_t Stream::Query(void) const uint16_t sqHead = 0U; uint16_t sqTail = 0U; error = device_->Driver_()->GetSqHead(device_->Id_(), device_->DevGetTsId(), this->GetSqId(), sqHead); - COND_RETURN_ERROR_MSG_INNER(error != RT_ERROR_NONE, - RT_ERROR_STREAM_NOT_COMPLETE, "Query sq head failed, retCode=%#x.", static_cast(error)); + COND_RETURN_ERROR_MSG_INNER( + error != RT_ERROR_NONE, RT_ERROR_STREAM_NOT_COMPLETE, "Query sq head failed, retCode=%#x.", + static_cast(error)); error = device_->Driver_()->GetSqTail(device_->Id_(), device_->DevGetTsId(), this->GetSqId(), sqTail); - COND_RETURN_ERROR_MSG_INNER(error != RT_ERROR_NONE, - RT_ERROR_STREAM_NOT_COMPLETE, "Query sq tail failed, retCode=%#x.", static_cast(error)); + COND_RETURN_ERROR_MSG_INNER( + error != RT_ERROR_NONE, RT_ERROR_STREAM_NOT_COMPLETE, "Query sq tail failed, retCode=%#x.", + static_cast(error)); if (sqHead != sqTail) { - RT_LOG(RT_LOG_DEBUG, "Task not complete, stream_id=%d, sqHead=%hu, sqTail=%hu", - this->Id_(), sqHead, sqTail); + RT_LOG( + RT_LOG_DEBUG, "Task not complete, stream_id=%d, sqHead=%hu, sqTail=%hu", this->Id_(), sqHead, sqTail); return RT_ERROR_STREAM_NOT_COMPLETE; } } else { uint32_t latestTskId = 0U; error = device_->QueryLatestTaskId(static_cast(streamId_), latestTskId); - COND_RETURN_ERROR(error != RT_ERROR_NONE, - RT_ERROR_STREAM_NOT_COMPLETE, "Query task id failed, retCode=%#x.", static_cast(error)); + COND_RETURN_ERROR( + error != RT_ERROR_NONE, RT_ERROR_STREAM_NOT_COMPLETE, "Query task id failed, retCode=%#x.", + static_cast(error)); if ((latestTskId == UINT32_MAX) || (latestTskId != lastTaskId_)) { - RT_LOG(RT_LOG_DEBUG, "Task not complete or query a invalid id," - " stream_id=%d, latestTskId=%u, lastTaskId_=%u", this->Id_(), latestTskId, lastTaskId_); + RT_LOG( + RT_LOG_DEBUG, + "Task not complete or query a invalid id," + " stream_id=%d, latestTskId=%u, lastTaskId_=%u", + this->Id_(), latestTskId, lastTaskId_); return RT_ERROR_STREAM_NOT_COMPLETE; } } @@ -2080,13 +2122,14 @@ rtError_t Stream::KernelFusionStart() fusioning_ = true; TaskInfo submitTask = {}; rtError_t errorReason; - TaskInfo *tsk = AllocTask(&submitTask, TS_TASK_TYPE_FUSION_ISSUE, errorReason); + TaskInfo* tsk = AllocTask(&submitTask, TS_TASK_TYPE_FUSION_ISSUE, errorReason); NULL_PTR_RETURN_MSG(tsk, errorReason); rtError_t error = KernelFusionTaskInit(tsk, FUSION_START); ERROR_GOTO_MSG_INNER(error, RECYCLE, "Init kernel fusion task failed, retCode=%#x.", static_cast(error)); error = device_->SubmitTask(tsk, (context_ != nullptr) ? context_->TaskGenCallback_() : nullptr); - ERROR_GOTO_MSG_INNER(error, RECYCLE, "Submit kernel fusion task failed, retCode=%#x.", static_cast(error)); + ERROR_GOTO_MSG_INNER( + error, RECYCLE, "Submit kernel fusion task failed, retCode=%#x.", static_cast(error)); return RT_ERROR_NONE; @@ -2099,20 +2142,21 @@ RECYCLE: rtError_t Stream::KernelFusionEnd() { if (!fusioning_) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, - "Run kernel fusion end failed, probably rtKernelFusionStart has not been called"); + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Run kernel fusion end failed, probably rtKernelFusionStart has not been called"); return RT_ERROR_STREAM_FUSION; } TaskInfo submitTask = {}; rtError_t errorReason; - TaskInfo *tsk = AllocTask(&submitTask, TS_TASK_TYPE_FUSION_ISSUE, errorReason); + TaskInfo* tsk = AllocTask(&submitTask, TS_TASK_TYPE_FUSION_ISSUE, errorReason); NULL_PTR_RETURN_MSG(tsk, errorReason); rtError_t error = KernelFusionTaskInit(tsk, FUSION_END); ERROR_GOTO_MSG_INNER(error, RECYCLE, "Init kernel fusion task failed, retCode=%#x.", static_cast(error)); error = device_->SubmitTask(tsk, (context_ != nullptr) ? context_->TaskGenCallback_() : nullptr); - ERROR_GOTO_MSG_INNER(error, RECYCLE, "Submit kernel fusion task failed, retCode=%#x.", static_cast(error)); + ERROR_GOTO_MSG_INNER( + error, RECYCLE, "Submit kernel fusion task failed, retCode=%#x.", static_cast(error)); fusioning_ = false; @@ -2123,7 +2167,7 @@ RECYCLE: return error; } -rtError_t Stream::FreePersistentTaskID(TaskAllocator * const tskAllocator) +rtError_t Stream::FreePersistentTaskID(TaskAllocator* const tskAllocator) { const rtError_t error = RT_ERROR_NONE; NULL_PTR_RETURN_MSG(tskAllocator, RT_ERROR_TASK_ALLOCATOR); @@ -2135,29 +2179,30 @@ rtError_t Stream::FreePersistentTaskID(TaskAllocator * const tskAllocator) return error; } -void Stream::FreePersistentTaskID(const Stream * const exeStream) +void Stream::FreePersistentTaskID(const Stream* const exeStream) { if (device_ == nullptr) { // 1910 may desconstruct stream in another thread, so device_ here may be nullptr. return; } - TaskFactory * const taskGenerator = device_->GetTaskFactory(); + TaskFactory* const taskGenerator = device_->GetTaskFactory(); if ((exeStream != this) && (taskGenerator != nullptr) && (taskGenerator->GetAllocator() != nullptr)) { const rtError_t error = this->FreePersistentTaskID(taskGenerator->GetAllocator()); COND_LOG_ERROR(error != RT_ERROR_NONE, "After teardown FreePersistentTaskID failed, retCode=%#x.", error); } } -bool Stream::NeedSaveTask(const TaskInfo * const tsk) const +bool Stream::NeedSaveTask(const TaskInfo* const tsk) const { if (((flags_ & RT_STREAM_AICPU) != 0U) && (tsk != nullptr)) { const tsTaskType_t type = tsk->type; - if ((type == TS_TASK_TYPE_ACTIVE_AICPU_STREAM) || (type == TS_TASK_TYPE_KERNEL_AICPU) - || (type == TS_TASK_TYPE_MODEL_END_GRAPH)) { + if ((type == TS_TASK_TYPE_ACTIVE_AICPU_STREAM) || (type == TS_TASK_TYPE_KERNEL_AICPU) || + (type == TS_TASK_TYPE_MODEL_END_GRAPH)) { const uint32_t modelId = static_cast(Id_()); const uint16_t taskId = tsk->id; - RT_LOG(RT_LOG_DEBUG, "need save task data, stream_id=%d, task_id=%u, task_type=%d(%s)", - modelId, static_cast(taskId), static_cast(type), tsk->typeName); + RT_LOG( + RT_LOG_DEBUG, "need save task data, stream_id=%d, task_id=%u, task_type=%d(%s)", modelId, + static_cast(taskId), static_cast(type), tsk->typeName); return true; } } @@ -2172,7 +2217,7 @@ bool Stream::NeedDelSelfStream(void) const uint32_t Stream::GetCbRptCqid() const { uint32_t tmpCqId = 0U; - Runtime * const rt = Runtime::Instance(); + Runtime* const rt = Runtime::Instance(); (void)rt->GetCqIdByStreamId(device_->Id_(), streamId_, &tmpCqId); return tmpCqId; } @@ -2180,17 +2225,14 @@ uint32_t Stream::GetCbRptCqid() const uint32_t Stream::GetCbGrpId() const { uint32_t grpId = 0U; - Runtime * const rt = Runtime::Instance(); + Runtime* const rt = Runtime::Instance(); (void)rt->GetGroupIdByStreamId(device_->Id_(), streamId_, &grpId); return grpId; } -bool Stream::IsHostFuncCbReg() -{ - return Runtime::Instance()->IsHostFuncCbReg(this); -} +bool Stream::IsHostFuncCbReg() { return Runtime::Instance()->IsHostFuncCbReg(this); } -bool Stream::IsDavinciTask(const TaskInfo * const tsk) const +bool Stream::IsDavinciTask(const TaskInfo* const tsk) const { const tsTaskType_t tskType = tsk->type; if ((tskType == TS_TASK_TYPE_KERNEL_AICORE) || (tskType == TS_TASK_TYPE_KERNEL_AICPU) || @@ -2200,13 +2242,13 @@ bool Stream::IsDavinciTask(const TaskInfo * const tsk) const return false; } -bool Stream::IsFusionKernelTask(const TaskInfo * const tsk) const +bool Stream::IsFusionKernelTask(const TaskInfo* const tsk) const { return (tsk->type == TS_TASK_TYPE_FUSION_KERNEL) ? true : false; } // add task to taskPublicBuff_ or davinciTaskList_ -rtError_t Stream::AddTaskToList(const TaskInfo * const tsk) +rtError_t Stream::AddTaskToList(const TaskInfo* const tsk) { if (isSupportASyncRecycle_ && (!IsNeedPostProc(tsk))) { if (isHasPcieBar_) { @@ -2215,44 +2257,47 @@ rtError_t Stream::AddTaskToList(const TaskInfo * const tsk) } const std::lock_guard stmLock(davinciTaskMutex_); - COND_RETURN_WARN(davinciTaskHead_ == ((davinciTaskTail_ + 1U) % davinciTaskListSize_), - RT_ERROR_STREAM_FULL, "davinci task list is full, stream_id=%d, task_id=%u, tail=%u", - streamId_, tsk->id, davinciTaskTail_); - davinciTaskList_[davinciTaskTail_ % davinciTaskListSize_] = tsk->id; - davinciTaskTail_ = ((davinciTaskTail_ + 1U) % davinciTaskListSize_); + COND_RETURN_WARN( + davinciTaskHead_ == ((davinciTaskTail_ + 1U) % davinciTaskListSize_), RT_ERROR_STREAM_FULL, + "davinci task list is full, stream_id=%d, task_id=%u, tail=%u", streamId_, tsk->id, davinciTaskTail_); + davinciTaskList_[davinciTaskTail_ % davinciTaskListSize_] = tsk->id; + davinciTaskTail_ = ((davinciTaskTail_ + 1U) % davinciTaskListSize_); } else { const std::lock_guard stmLock(publicTaskMutex_); - COND_RETURN_WARN(taskHead_ == ((taskTail_ + 1U) % taskPublicBuffSize_), - RT_ERROR_STREAM_FULL, "task public buff full, stream_id=%d, task_id=%hu, tail=%u", - streamId_, tsk->id, taskTail_); - taskPublicBuff_[taskTail_ % taskPublicBuffSize_] = tsk->id; - taskTail_ = ((taskTail_ + 1U) % taskPublicBuffSize_); + COND_RETURN_WARN( + taskHead_ == ((taskTail_ + 1U) % taskPublicBuffSize_), RT_ERROR_STREAM_FULL, + "task public buff full, stream_id=%d, task_id=%hu, tail=%u", streamId_, tsk->id, taskTail_); + taskPublicBuff_[taskTail_ % taskPublicBuffSize_] = tsk->id; + taskTail_ = ((taskTail_ + 1U) % taskPublicBuffSize_); } return RT_ERROR_NONE; } -rtError_t Stream::AddTaskToStream(const TaskInfo * const tsk) +rtError_t Stream::AddTaskToStream(const TaskInfo* const tsk) { NULL_PTR_RETURN_MSG(tsk, RT_ERROR_TASK_NULL); ZERO_RETURN_MSG(taskPublicBuffSize_); if (static_cast(tsk->bindFlag)) { - COND_RETURN_WARN(taskPersistentHead_.Value() == ((taskPersistentTail_.Value() + 1U) % STREAM_TASK_BUFF_SIZE), - RT_ERROR_STREAM_FULL, "task persistent buff full, stream_id=%d, task_id=%hu, tail=%u", - streamId_, tsk->id, taskPersistentTail_.Value()); + COND_RETURN_WARN( + taskPersistentHead_.Value() == ((taskPersistentTail_.Value() + 1U) % STREAM_TASK_BUFF_SIZE), + RT_ERROR_STREAM_FULL, "task persistent buff full, stream_id=%d, task_id=%hu, tail=%u", streamId_, tsk->id, + taskPersistentTail_.Value()); const rtError_t ret = PackingTaskGroup(tsk, static_cast(streamId_)); - COND_PROC_RETURN_ERROR(ret != RT_ERROR_NONE, ret, SetTaskGroupErrCode(ret), - "pack task group failed, stream_id=%d, task_id=%hu.", streamId_, tsk->id); + COND_PROC_RETURN_ERROR( + ret != RT_ERROR_NONE, ret, SetTaskGroupErrCode(ret), "pack task group failed, stream_id=%d, task_id=%hu.", + streamId_, tsk->id); taskPersistentBuff_[taskPersistentTail_.Value() % STREAM_TASK_BUFF_SIZE] = tsk->id; taskPersistentTail_.Set((taskPersistentTail_.Value() + 1U) % STREAM_TASK_BUFF_SIZE); delayRecycleTaskid_.push_back(tsk->id); - RT_LOG(RT_LOG_INFO, "persistent task, stream_id=%d, task_id=%hu, task_type=%d (%s), " + RT_LOG( + RT_LOG_INFO, + "persistent task, stream_id=%d, task_id=%hu, task_type=%d (%s), " "head=%u, tail=%u, delay recycle task num=%zu.", - streamId_, tsk->id, static_cast(tsk->type), tsk->typeName, - taskPersistentHead_.Value(), taskPersistentTail_.Value(), - delayRecycleTaskid_.size()); + streamId_, tsk->id, static_cast(tsk->type), tsk->typeName, taskPersistentHead_.Value(), + taskPersistentTail_.Value(), delayRecycleTaskid_.size()); } else { const rtError_t ret = AddTaskToList(tsk); COND_RETURN_WITH_NOLOG((ret != RT_ERROR_NONE), ret); @@ -2266,7 +2311,7 @@ rtError_t Stream::AddTaskToStream(const TaskInfo * const tsk) void Stream::EraseCacheStream() { if (delayRecycleTaskid_.empty()) { - Profiler * const profilerPtr = Runtime::Instance()->Profiler_(); + Profiler* const profilerPtr = Runtime::Instance()->Profiler_(); if (profilerPtr != nullptr) { profilerPtr->EraseStream(this); } @@ -2276,16 +2321,13 @@ void Stream::EraseCacheStream() // insert stream when bind model void Stream::InsertCacheStream() { - Profiler * const profilerPtr = Runtime::Instance()->Profiler_(); + Profiler* const profilerPtr = Runtime::Instance()->Profiler_(); if (profilerPtr != nullptr) { profilerPtr->InsertStream(this); } } -const std::list &Stream::GetCacheTrackTaskList() const -{ - return cacheTrackTaskid_; -} +const std::list& Stream::GetCacheTrackTaskList() const { return cacheTrackTaskid_; } void Stream::SetMaxTaskId(const bool isDisableThread) { @@ -2294,10 +2336,10 @@ void Stream::SetMaxTaskId(const bool isDisableThread) RT_LOG(RT_LOG_DEBUG, "SetMaxTaskId, maxTaskId_=%hu", maxTaskId_); } -rtError_t Stream::ProcFlipTask(TaskInfo *&tsk, uint16_t flipNum) +rtError_t Stream::ProcFlipTask(TaskInfo*& tsk, uint16_t flipNum) { rtError_t errorReason; - TaskInfo *rtFlipTask = AllocTask(tsk, TS_TASK_TYPE_FLIP, errorReason, 1U, UpdateTaskFlag::NOT_SUPPORT_AND_SKIP); + TaskInfo* rtFlipTask = AllocTask(tsk, TS_TASK_TYPE_FLIP, errorReason, 1U, UpdateTaskFlag::NOT_SUPPORT_AND_SKIP); NULL_PTR_RETURN_MSG(rtFlipTask, errorReason); tsk = rtFlipTask; @@ -2307,8 +2349,11 @@ rtError_t Stream::ProcFlipTask(TaskInfo *&tsk, uint16_t flipNum) bool Stream::IsNeedSendFlipTask(uint16_t preTaskId) { - RT_LOG(RT_LOG_DEBUG, "IsNeedSendFlipTask, preTaskId=%hu, maxTaskId=%hu, trackProfFlag=%d, isCtrlStream_=%d, isTsSupport=%d.", - preTaskId, GetMaxTaskId(), Runtime::Instance()->GetTrackProfFlag(), isCtrlStream_, device_->IsSupportTsVersionForFlipTask()); + RT_LOG( + RT_LOG_DEBUG, + "IsNeedSendFlipTask, preTaskId=%hu, maxTaskId=%hu, trackProfFlag=%d, isCtrlStream_=%d, isTsSupport=%d.", + preTaskId, GetMaxTaskId(), Runtime::Instance()->GetTrackProfFlag(), isCtrlStream_, + device_->IsSupportTsVersionForFlipTask()); if (preTaskId != GetMaxTaskId()) { return false; } @@ -2330,7 +2375,7 @@ void Stream::ReportDestroyFlipTask() return; } - Profiler *profilerPtr = Runtime::Instance()->Profiler_(); + Profiler* profilerPtr = Runtime::Instance()->Profiler_(); if (profilerPtr != nullptr) { profilerPtr->ReportDestroyFlipTask(this, device_->Id_()); } @@ -2345,17 +2390,19 @@ rtError_t Stream::TryDelRecordedTask(const bool isTaskBind, const uint16_t tailT const uint32_t fixTaskId = taskPublicBuff_[taskHead_ % taskPublicBuffSize_]; const uint16_t relTaskId = static_cast(fixTaskId & 0xFFFFU); if (TASK_ID_GT(relTaskId, tailTaskId)) { - RT_LOG(RT_LOG_DEBUG, "delTaskId is greater than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u," - " head=%u, tail=%u", streamId_, static_cast(tailTaskId), static_cast(relTaskId), - taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, + "delTaskId is greater than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u," + " head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(relTaskId), taskHead_, taskTail_); return RT_ERROR_STREAM_INVALID; } taskHead_ = ((taskHead_ + 1U) % taskPublicBuffSize_); earlyRecycleTaskHead_ = (taskHead_ % STREAM_PUBLIC_TASK_BUFF_SIZE); - RT_LOG(RT_LOG_DEBUG, "del public task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), static_cast(relTaskId), - taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, "del public task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%u, head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(relTaskId), taskHead_, taskTail_); finishTaskId_ = relTaskId; return RT_ERROR_NONE; } @@ -2364,35 +2411,41 @@ rtError_t Stream::TryDelRecordedTask(const bool isTaskBind, const uint16_t tailT if (isTaskBind) { if (taskPersistentHead_.Value() == taskPersistentTail_.Value()) { - RT_LOG(RT_LOG_ERROR, "Task persistent buff null, stream_id=%d, task_id=%u, head=%u, tail=%u.", - streamId_, static_cast(tailTaskId), taskPersistentHead_.Value(), - taskPersistentTail_.Value()); + RT_LOG( + RT_LOG_ERROR, "Task persistent buff null, stream_id=%d, task_id=%u, head=%u, tail=%u.", streamId_, + static_cast(tailTaskId), taskPersistentHead_.Value(), taskPersistentTail_.Value()); return RT_ERROR_STREAM_EMPTY; } delTaskId = taskPersistentBuff_[taskPersistentHead_.Value() % STREAM_TASK_BUFF_SIZE]; taskPersistentHead_.Set((taskPersistentHead_.Value() + 1U) % STREAM_TASK_BUFF_SIZE); - RT_LOG(RT_LOG_DEBUG, "del persistent task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%hu, " - "head=%u, tail=%u", streamId_, static_cast(tailTaskId), delTaskId, - taskPersistentHead_.Value(), taskPersistentTail_.Value()); + RT_LOG( + RT_LOG_DEBUG, + "del persistent task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%hu, " + "head=%u, tail=%u", + streamId_, static_cast(tailTaskId), delTaskId, taskPersistentHead_.Value(), + taskPersistentTail_.Value()); } else { if (taskHead_ == taskTail_) { - RT_LOG(RT_LOG_DEBUG, "task public buff null, stream_id=%d, task_id=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, "task public buff null, stream_id=%d, task_id=%u, head=%u, tail=%u", streamId_, + static_cast(tailTaskId), taskHead_, taskTail_); return RT_ERROR_STREAM_EMPTY; } delTaskId = static_cast(taskPublicBuff_[taskHead_ % taskPublicBuffSize_]); taskHead_ = ((taskHead_ + 1U) % taskPublicBuffSize_); earlyRecycleTaskHead_ = (taskHead_ % STREAM_PUBLIC_TASK_BUFF_SIZE); - RT_LOG(RT_LOG_DEBUG, "del public task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%hu, " - "head=%u, tail=%u", streamId_, static_cast(tailTaskId), delTaskId, - taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, + "del public task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%hu, " + "head=%u, tail=%u", + streamId_, static_cast(tailTaskId), delTaskId, taskHead_, taskTail_); } finishTaskId_ = delTaskId; return RT_ERROR_NONE; } -rtError_t Stream::GetPublicTaskHead(const bool isTaskBind, const uint16_t tailTaskId, uint16_t * const delTaskId) +rtError_t Stream::GetPublicTaskHead(const bool isTaskBind, const uint16_t tailTaskId, uint16_t* const delTaskId) { NULL_PTR_RETURN_MSG(delTaskId, RT_ERROR_TASK_NULL); ZERO_RETURN_MSG(taskPublicBuffSize_); @@ -2401,9 +2454,11 @@ rtError_t Stream::GetPublicTaskHead(const bool isTaskBind, const uint16_t tailTa const uint32_t fixTaskId = taskPublicBuff_[taskHead_ % taskPublicBuffSize_]; const uint16_t relTaskId = static_cast(fixTaskId & 0xFFFFU); if (TASK_ID_GT(relTaskId, tailTaskId)) { - RT_LOG(RT_LOG_DEBUG, "delTaskId is greater than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u," - " head=%u, tail=%u", streamId_, static_cast(tailTaskId), static_cast(relTaskId), - taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, + "delTaskId is greater than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u," + " head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(relTaskId), taskHead_, taskTail_); return RT_ERROR_STREAM_INVALID; } *delTaskId = relTaskId; @@ -2412,16 +2467,17 @@ rtError_t Stream::GetPublicTaskHead(const bool isTaskBind, const uint16_t tailTa if (isTaskBind) { if (taskPersistentHead_.Value() == taskPersistentTail_.Value()) { - RT_LOG(RT_LOG_ERROR, "Task persistent buff null, stream_id=%d, task_id=%u, head=%u, tail=%u.", - streamId_, static_cast(tailTaskId), taskPersistentHead_.Value(), - taskPersistentTail_.Value()); + RT_LOG( + RT_LOG_ERROR, "Task persistent buff null, stream_id=%d, task_id=%u, head=%u, tail=%u.", streamId_, + static_cast(tailTaskId), taskPersistentHead_.Value(), taskPersistentTail_.Value()); return RT_ERROR_STREAM_EMPTY; } *delTaskId = taskPersistentBuff_[taskPersistentHead_.Value() % STREAM_TASK_BUFF_SIZE]; } else { if (taskHead_ == taskTail_) { - RT_LOG(RT_LOG_DEBUG, "task public buff null, stream_id=%d, task_id=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, "task public buff null, stream_id=%d, task_id=%u, head=%u, tail=%u", streamId_, + static_cast(tailTaskId), taskHead_, taskTail_); return RT_ERROR_STREAM_EMPTY; } *delTaskId = taskPublicBuff_[taskHead_ % taskPublicBuffSize_]; @@ -2430,7 +2486,7 @@ rtError_t Stream::GetPublicTaskHead(const bool isTaskBind, const uint16_t tailTa return RT_ERROR_NONE; } -rtError_t Stream::TryDelDavinciRecordedTask(const uint16_t tailTaskId, uint16_t * const delTaskId) +rtError_t Stream::TryDelDavinciRecordedTask(const uint16_t tailTaskId, uint16_t* const delTaskId) { if (!Runtime::Instance()->GetDisableThread()) { return RT_ERROR_STREAM_EMPTY; @@ -2446,22 +2502,27 @@ rtError_t Stream::TryDelDavinciRecordedTask(const uint16_t tailTaskId, uint16_t const uint32_t fixTaskId = davinciTaskList_[davinciTaskHead_ % davinciTaskListSize_]; const uint16_t relTaskId = static_cast(fixTaskId & 0xFFFFU); if (TASK_ID_GT(relTaskId, tailTaskId)) { - RT_LOG(RT_LOG_DEBUG, "delTaskId is greater than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u," - " head=%u, tail=%u", streamId_, static_cast(tailTaskId), static_cast(relTaskId), - davinciTaskHead_, davinciTaskTail_); + RT_LOG( + RT_LOG_DEBUG, + "delTaskId is greater than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u," + " head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(relTaskId), davinciTaskHead_, + davinciTaskTail_); return RT_ERROR_STREAM_INVALID; } *delTaskId = relTaskId; davinciTaskHead_ = ((davinciTaskHead_ + 1U) % davinciTaskListSize_); - RT_LOG(RT_LOG_DEBUG, "del public task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), static_cast(relTaskId), - davinciTaskHead_, davinciTaskTail_); + RT_LOG( + RT_LOG_DEBUG, "del public task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%u, head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(relTaskId), davinciTaskHead_, + davinciTaskTail_); finishTaskId_ = relTaskId; return RT_ERROR_NONE; } else { - RT_LOG(RT_LOG_DEBUG, "davinci task list null, stream_id=%d, task_id=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), davinciTaskHead_, davinciTaskTail_); + RT_LOG( + RT_LOG_DEBUG, "davinci task list null, stream_id=%d, task_id=%u, head=%u, tail=%u", streamId_, + static_cast(tailTaskId), davinciTaskHead_, davinciTaskTail_); return RT_ERROR_STREAM_EMPTY; } } @@ -2476,7 +2537,9 @@ void Stream::BatchDelDavinciRecordedTask(const uint16_t tailTaskId, const uint32 TIMESTAMP_BEGIN(BatchDelDavinciRecordedTask); pendingNum_.Sub(davinciTaskNum); finishTaskId_ = tailTaskId; - RT_LOG(RT_LOG_DEBUG, "batch del davinci task from stream, stream_id=%d, tailTaskId=%u," + RT_LOG( + RT_LOG_DEBUG, + "batch del davinci task from stream, stream_id=%d, tailTaskId=%u," " finishTaskId=%u, recycleTaskNum=%u.", streamId_, static_cast(tailTaskId), finishTaskId_, davinciTaskNum); @@ -2484,15 +2547,16 @@ void Stream::BatchDelDavinciRecordedTask(const uint16_t tailTaskId, const uint32 return; } -int32_t Stream::GetRecycleTaskHeadId(const uint16_t tailTaskId, uint16_t &recycleTaskId) +int32_t Stream::GetRecycleTaskHeadId(const uint16_t tailTaskId, uint16_t& recycleTaskId) { const std::lock_guard stmLock(publicTaskMutex_); if (earlyRecycleTaskHead_ != taskTail_) { recycleTaskId = taskPublicBuff_[earlyRecycleTaskHead_ % STREAM_PUBLIC_TASK_BUFF_SIZE]; earlyRecycleTaskHead_ = ((earlyRecycleTaskHead_ + 1U) % STREAM_PUBLIC_TASK_BUFF_SIZE); - RT_LOG(RT_LOG_INFO, "get task headId from stream, stream_id=%d, tailTaskId=%u, TaskId=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), static_cast(recycleTaskId), - earlyRecycleTaskHead_, taskTail_); + RT_LOG( + RT_LOG_INFO, "get task headId from stream, stream_id=%d, tailTaskId=%u, TaskId=%u, head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(recycleTaskId), earlyRecycleTaskHead_, + taskTail_); } else { RT_LOG(RT_LOG_INFO, "earlyRecycleTaskHead_ value is equal taskTail_[%u]", static_cast(tailTaskId)); return RT_ERROR_STREAM_EMPTY; @@ -2512,10 +2576,10 @@ void Stream::ClearTaskCount(const bool isTaskBind) uint8_t Stream::GetTaskRevFlag(const bool isTaskBind) { if (isTaskBind) { - if (((countingPersistentNum_.Value() + 1U) % TASK_NO_SEND_CQ_MAX) == 0U || - IsPersistentTaskFull()) { + if (((countingPersistentNum_.Value() + 1U) % TASK_NO_SEND_CQ_MAX) == 0U || IsPersistentTaskFull()) { countingPersistentNum_.Set(0U); - RT_LOG(RT_LOG_INFO, "set recv cq flag when persistent task count=%u, isPersistentTaskFull=%u", + RT_LOG( + RT_LOG_INFO, "set recv cq flag when persistent task count=%u, isPersistentTaskFull=%u", TASK_NO_SEND_CQ_MAX, IsPersistentTaskFull()); return TASK_NEED_SEND_CQ; } else { @@ -2534,62 +2598,43 @@ uint8_t Stream::GetTaskRevFlag(const bool isTaskBind) } } -void Stream::StreamLock() -{ - streamMutex_.lock(); -} +void Stream::StreamLock() { streamMutex_.lock(); } -void Stream::StreamUnLock() -{ - streamMutex_.unlock(); -} +void Stream::StreamUnLock() { streamMutex_.unlock(); } -void Stream::StreamSyncLock() -{ - streamSyncMutex_.lock(); -} +void Stream::StreamSyncLock() { streamSyncMutex_.lock(); } -bool Stream::StreamSyncTryLock(uint64_t time) -{ - return streamSyncMutex_.try_lock_for(std::chrono::milliseconds(time)); -} +bool Stream::StreamSyncTryLock(uint64_t time) { return streamSyncMutex_.try_lock_for(std::chrono::milliseconds(time)); } -void Stream::StreamSyncUnLock() -{ - streamSyncMutex_.unlock(); -} +void Stream::StreamSyncUnLock() { streamSyncMutex_.unlock(); } -void Stream::StreamRecycleLock() -{ - recycleMutex_.lock(); -} +void Stream::StreamRecycleLock() { recycleMutex_.lock(); } -void Stream::StreamRecycleUnlock() -{ - recycleMutex_.unlock(); -} +void Stream::StreamRecycleUnlock() { recycleMutex_.unlock(); } -rtError_t Stream::AcquireTimeline(uint64_t &base, uint32_t &offset) +rtError_t Stream::AcquireTimeline(uint64_t& base, uint32_t& offset) { - constexpr uint32_t maxTimelineNum = 512U; // 4K. + constexpr uint32_t maxTimelineNum = 512U; // 4K. const std::lock_guard timelineLock(timelineMutex_); if (timelineAddr_ == nullptr) { - Driver * const devDrv = device_->Driver_(); + Driver* const devDrv = device_->Driver_(); constexpr uint32_t maxTimelineSize = maxTimelineNum * sizeof(uint64_t); - Runtime * const rtInstance = Runtime::Instance(); + Runtime* const rtInstance = Runtime::Instance(); const rtMemType_t memType = rtInstance->GetTsMemType(MEM_REQUEST_FEATURE_DEFAULT, maxTimelineSize); - rtError_t error = devDrv->DevMemAlloc(RtPtrToPtr(&timelineAddr_), - maxTimelineSize, memType, device_->Id_()); - ERROR_RETURN(error, "Malloc timeline buffer failed, type=%u, error=%#x", - static_cast(memType), static_cast(error)); + rtError_t error = + devDrv->DevMemAlloc(RtPtrToPtr(&timelineAddr_), maxTimelineSize, memType, device_->Id_()); + ERROR_RETURN( + error, "Malloc timeline buffer failed, type=%u, error=%#x", static_cast(memType), + static_cast(error)); error = devDrv->MemSetSync(timelineAddr_, maxTimelineSize, 0xFFU, maxTimelineSize); - ERROR_RETURN(error, "Memset timeline buffer failed, type=%u, error=%#x.", - static_cast(memType), static_cast(error)); + ERROR_RETURN( + error, "Memset timeline buffer failed, type=%u, error=%#x.", static_cast(memType), + static_cast(error)); - error = devDrv->MemAddressTranslate(static_cast(device_->Id_()), - RtPtrToValue(timelineAddr_), &timelineBase_); + error = devDrv->MemAddressTranslate( + static_cast(device_->Id_()), RtPtrToValue(timelineAddr_), &timelineBase_); ERROR_RETURN(error, "Convert address to physical failed! error=%#x.", static_cast(error)); RT_LOG(RT_LOG_DEBUG, "stream_id=%d, base=%#" PRIx64 "", streamId_, timelineBase_); } @@ -2599,8 +2644,8 @@ rtError_t Stream::AcquireTimeline(uint64_t &base, uint32_t &offset) base = timelineBase_; offset = i; (void)timelineOffset_.insert(i); - RT_LOG(RT_LOG_DEBUG, "Acquire Timeline, stream_id=%d, base=%#" PRIx64 ", offset=%u", - streamId_, base, offset); + RT_LOG( + RT_LOG_DEBUG, "Acquire Timeline, stream_id=%d, base=%#" PRIx64 ", offset=%u", streamId_, base, offset); return RT_ERROR_NONE; } } @@ -2614,8 +2659,9 @@ rtError_t Stream::ReleaseTimeline(const uint64_t base, const uint32_t offset) RT_LOG(RT_LOG_DEBUG, "Release Timeline, stream_id=%d, base=%#" PRIx64 ", offset=%u.", streamId_, base, offset); const std::lock_guard timelineLock(timelineMutex_); if (base != timelineBase_) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, "Release timeline failed, base=%#" PRIx64 " is invalid, valid value=%#" PRIx64, - base, timelineBase_); + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Release timeline failed, base=%#" PRIx64 " is invalid, valid value=%#" PRIx64, base, + timelineBase_); return RT_ERROR_INVALID_VALUE; } @@ -2633,8 +2679,9 @@ uint64_t Stream::GetTimelineValue(const uint64_t base, const uint32_t offset) { uint64_t val = 0U; if (base != timelineBase_) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, "Get timeline failed, base=%#" PRIx64 " is invalid, valid value=%#" PRIx64, - base, timelineBase_); + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Get timeline failed, base=%#" PRIx64 " is invalid, valid value=%#" PRIx64, base, + timelineBase_); return val; } @@ -2645,20 +2692,21 @@ uint64_t Stream::GetTimelineValue(const uint64_t base, const uint32_t offset) return val; } - Driver * const dev = device_->Driver_(); - const rtError_t error = dev->MemCopySync(&val, sizeof(uint64_t), timelineAddr_ + offset, sizeof(uint64_t), - RT_MEMCPY_DEVICE_TO_HOST); + Driver* const dev = device_->Driver_(); + const rtError_t error = + dev->MemCopySync(&val, sizeof(uint64_t), timelineAddr_ + offset, sizeof(uint64_t), RT_MEMCPY_DEVICE_TO_HOST); if (error != RT_ERROR_NONE) { RT_LOG(RT_LOG_ERROR, "Copy Timeline failed, error=%#x", static_cast(error)); return val; } - RT_LOG(RT_LOG_DEBUG, "Timeline stream_id=%u, base=%#" PRIx64 ", offset=%u, value=%#" PRIx64, - streamId_, base, offset, val); + RT_LOG( + RT_LOG_DEBUG, "Timeline stream_id=%u, base=%#" PRIx64 ", offset=%u, value=%#" PRIx64, streamId_, base, offset, + val); return val; } -void Stream::SetStreamMark(const TaskInfo * const tsk) +void Stream::SetStreamMark(const TaskInfo* const tsk) { if (IsTaskSink()) { return; @@ -2671,7 +2719,7 @@ void Stream::SetStreamMark(const TaskInfo * const tsk) } } -bool Stream::IsTaskLimited(const TaskInfo * const tsk) +bool Stream::IsTaskLimited(const TaskInfo* const tsk) { UNUSED(tsk); if (IsTaskSink()) { @@ -2691,24 +2739,25 @@ bool Stream::IsTaskLimited(const TaskInfo * const tsk) RT_LOG(RT_LOG_DEBUG, "Sending task is limited, stream_id=%d, pendingNum=%u", streamId_, pendingNum_.Value()); - return true; // Event not happen, need wait. + return true; // Event not happen, need wait. } -rtError_t Stream::ProcRecordTask(TaskInfo *&tsk) +rtError_t Stream::ProcRecordTask(TaskInfo*& tsk) { const std::lock_guard stmLock(streamMutex_); rtError_t error = RT_ERROR_NONE; rtError_t errorReason; if (lastHalfRecord_ == nullptr) { lastHalfRecord_ = new (std::nothrow) Event(device_, RT_EVENT_STREAM_MARK, Context_(), true); - COND_RETURN_AND_MSG_OUTER(lastHalfRecord_ == nullptr, RT_ERROR_EVENT_NEW, ErrorCode::EE1013, sizeof(Event), "new"); + COND_RETURN_AND_MSG_OUTER( + lastHalfRecord_ == nullptr, RT_ERROR_EVENT_NEW, ErrorCode::EE1013, sizeof(Event), "new"); error = lastHalfRecord_->GenEventId(); COND_PROC_RETURN_ERROR(error != RT_ERROR_NONE, error, DELETE_O(lastHalfRecord_), "Alloc event id failed."); } - TaskInfo *eventRecordTsk = AllocTask(tsk, TS_TASK_TYPE_EVENT_RECORD, errorReason, 1U, UpdateTaskFlag::NOT_SUPPORT_AND_SKIP); - COND_PROC_RETURN_ERROR(eventRecordTsk == nullptr, errorReason, DELETE_O(lastHalfRecord_), - "Alloc task failed."); + TaskInfo* eventRecordTsk = + AllocTask(tsk, TS_TASK_TYPE_EVENT_RECORD, errorReason, 1U, UpdateTaskFlag::NOT_SUPPORT_AND_SKIP); + COND_PROC_RETURN_ERROR(eventRecordTsk == nullptr, errorReason, DELETE_O(lastHalfRecord_), "Alloc task failed."); tsk = eventRecordTsk; error = EventRecordTaskInit(eventRecordTsk, lastHalfRecord_, true, lastHalfRecord_->EventId_()); @@ -2745,7 +2794,8 @@ rtError_t Stream::WaitTask(bool const isReclaim, const uint32_t taskId, const in uint64_t count; const uint32_t deviceId = device_->Id_(); - RT_LOG(RT_LOG_INFO, "Begin wait task, device_id=%u, stream_id=%d, task_id=%u, finish_task_id=%u, last_task_id=%u", + RT_LOG( + RT_LOG_INFO, "Begin wait task, device_id=%u, stream_id=%d, task_id=%u, finish_task_id=%u, last_task_id=%u", deviceId, streamId_, taskId, finishTaskId_, lastTaskId_); beginTimeSpec = mmGetTickCount(); @@ -2764,19 +2814,22 @@ rtError_t Stream::WaitTask(bool const isReclaim, const uint32_t taskId, const in } this->SetSyncRemainTime(-1); StreamSyncUnLock(); - COND_RETURN_ERROR_MSG_INNER(error != RT_ERROR_NONE, error, - "Failed to reclaim the task, retCode=%#x.", static_cast(error)); + COND_RETURN_ERROR_MSG_INNER( + error != RT_ERROR_NONE, error, "Failed to reclaim the task, retCode=%#x.", + static_cast(error)); } else { error = GetLastFinishTaskId(taskId, currId, timeout); - COND_RETURN_ERROR_MSG_INNER(error != RT_ERROR_NONE, error, "Get finish TaskId failed, retCode=%#x.", static_cast(error)); + COND_RETURN_ERROR_MSG_INNER( + error != RT_ERROR_NONE, error, "Get finish TaskId failed, retCode=%#x.", static_cast(error)); } if (IsWaitFinish(currId, taskId)) { // Event occurred. - RT_LOG(RT_LOG_DEBUG, "Wait finish, device_id=%u, stream_id=%d, task_id=%u, current_id=%u", - deviceId, streamId_, taskId, currId); + RT_LOG( + RT_LOG_DEBUG, "Wait finish, device_id=%u, stream_id=%d, task_id=%u, current_id=%u", deviceId, streamId_, + taskId, currId); return RT_ERROR_NONE; } - if (abortStatus_ == RT_ERROR_STREAM_ABORT) { + if (abortStatus_ == RT_ERROR_STREAM_ABORT) { RT_LOG_INNER_MSG(RT_LOG_ERROR, "The stream %u is in abort state.", streamId_); return RT_ERROR_STREAM_ABORT; } @@ -2793,7 +2846,8 @@ rtError_t Stream::WaitTask(bool const isReclaim, const uint32_t taskId, const in static_cast(endTimeSpec.tv_nsec) / RT_MS_TO_NS; count = endCnt > beginCnt ? (endCnt - beginCnt) : 0; if (count >= static_cast(timeout)) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, "Stream synchronize timeout, device_id=%u, stream_id=%d, time=%lums, timeout=%dms.", + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Stream synchronize timeout, device_id=%u, stream_id=%d, time=%lums, timeout=%dms.", deviceId, streamId_, count, timeout); return RT_ERROR_STREAM_SYNC_TIMEOUT; } @@ -2803,14 +2857,15 @@ rtError_t Stream::WaitTask(bool const isReclaim, const uint32_t taskId, const in return RT_ERROR_NONE; } -rtError_t Stream::QueryWaitTask(bool &isWaitFlag, const uint32_t taskId) +rtError_t Stream::QueryWaitTask(bool& isWaitFlag, const uint32_t taskId) { isWaitFlag = false; uint32_t currId = 0U; rtError_t error = RT_ERROR_NONE; - RT_LOG(RT_LOG_DEBUG, "Begin query wait task, stream_id=%d, task_id=%u, finish_task_id=%u, last_task_id=%u", - streamId_, taskId, finishTaskId_, lastTaskId_); + RT_LOG( + RT_LOG_DEBUG, "Begin query wait task, stream_id=%d, task_id=%u, finish_task_id=%u, last_task_id=%u", streamId_, + taskId, finishTaskId_, lastTaskId_); if (device_->IsStarsPlatform()) { error = GetLastTaskIdFromRtsq(currId); @@ -2820,7 +2875,8 @@ rtError_t Stream::QueryWaitTask(bool &isWaitFlag, const uint32_t taskId) } } else { error = device_->QueryLatestTaskId(static_cast(streamId_), currId); - COND_RETURN_ERROR(error != RT_ERROR_NONE, error, "Query Task status failed, retCode=%#x.", static_cast(error)); + COND_RETURN_ERROR( + error != RT_ERROR_NONE, error, "Query Task status failed, retCode=%#x.", static_cast(error)); if (currId == UINT32_MAX) { isWaitFlag = false; return RT_ERROR_NONE; @@ -2835,10 +2891,11 @@ rtError_t Stream::QueryWaitTask(bool &isWaitFlag, const uint32_t taskId) return RT_ERROR_NONE; } -rtError_t Stream::GetLastTaskIdFromCqShm(uint32_t &lastTaskId) +rtError_t Stream::GetLastTaskIdFromCqShm(uint32_t& lastTaskId) { - RT_LOG(RT_LOG_DEBUG, "Begin query task, stream_id=%d, finish_task_id=%u, last_task_id=%u", - streamId_, finishTaskId_, lastTaskId_); + RT_LOG( + RT_LOG_DEBUG, "Begin query task, stream_id=%d, finish_task_id=%u, last_task_id=%u", streamId_, finishTaskId_, + lastTaskId_); if (device_ != nullptr) { const rtError_t error = device_->QueryLatestTaskId(static_cast(streamId_), lastTaskId); COND_RETURN_ERROR(error != RT_ERROR_NONE, error, "Query Task status failed."); @@ -2874,7 +2931,7 @@ bool Stream::IsSyncFinished() } if (IsSeparateSendAndRecycle()) { return IsTaskExcuted(executeEndTaskid_.Value(), lastTaskId_) && - (latestConcernedTaskId.Value() == MAX_UINT16_NUM); + (latestConcernedTaskId.Value() == MAX_UINT16_NUM); } else { return GetPendingNum() == 0U; } @@ -2890,8 +2947,11 @@ rtError_t Stream::WaitForTask(const uint32_t taskId, const bool isNeedWaitSyncCq rtError_t error = RT_ERROR_NONE; uint32_t currentId = 0U; - RT_LOG(RT_LOG_DEBUG, "Begin wait for task, device_id=%u, ts_id=%u, stream_id=%d, task_id=%u, finish_task_id=%u, " - "last_task_id=%u, timeout=%dms", deviceId, tsId, streamId_, taskId, finishTaskId_, lastTaskId_, timeout); + RT_LOG( + RT_LOG_DEBUG, + "Begin wait for task, device_id=%u, ts_id=%u, stream_id=%d, task_id=%u, finish_task_id=%u, " + "last_task_id=%u, timeout=%dms", + deviceId, tsId, streamId_, taskId, finishTaskId_, lastTaskId_, timeout); const uint32_t maxTryCount = GetMaxTryCount(); @@ -2907,23 +2967,28 @@ rtError_t Stream::WaitForTask(const uint32_t taskId, const bool isNeedWaitSyncCq #endif StreamSyncUnLock(); if (error != RT_ERROR_NONE) { - RT_LOG(RT_LOG_ERROR, "Query Task status failed, device_id=%u, ts_id=%u, stream_id=%d, retCode=%#x", - deviceId, tsId, streamId_, error); + RT_LOG( + RT_LOG_ERROR, "Query Task status failed, device_id=%u, ts_id=%u, stream_id=%d, retCode=%#x", deviceId, + tsId, streamId_, error); return error; } // Event occurred. if ((currentId != UINT32_MAX) && TASK_ID_GEQ(currentId, taskId)) { StreamSyncFinishReport(); - RT_LOG(RT_LOG_DEBUG, "Wait finish, device_id=%u, ts_id=%u, stream_id=%d, task_id=%u, current_id=%u, " - "tryCount=%u", deviceId, tsId, streamId_, taskId, currentId, tryCount); + RT_LOG( + RT_LOG_DEBUG, + "Wait finish, device_id=%u, ts_id=%u, stream_id=%d, task_id=%u, current_id=%u, " + "tryCount=%u", + deviceId, tsId, streamId_, taskId, currentId, tryCount); return RT_ERROR_NONE; } if (tryCount >= maxTryCount) { if (timeout > 0) { uint64_t count = GetTimeInterval(beginTimeSpec); - COND_RETURN_ERROR_MSG_INNER((count >= static_cast(timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, + COND_RETURN_ERROR_MSG_INNER( + (count >= static_cast(timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, "Stream synchronize timeout, device_id=%u, stream_id=%d, time=%lums, timeout=%dms, tryCount=%u.", deviceId, streamId_, count, timeout, tryCount); timeout = (timeout - static_cast(count)); @@ -2942,7 +3007,8 @@ rtError_t Stream::WaitForTask(const uint32_t taskId, const bool isNeedWaitSyncCq if ((tryCount % perSchedYield) == 0) { if (timeout > 0) { uint64_t count = GetTimeInterval(beginTimeSpec); - COND_RETURN_ERROR_MSG_INNER((count >= static_cast(timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, + COND_RETURN_ERROR_MSG_INNER( + (count >= static_cast(timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, "Stream synchronize timeout, device_id=%u, stream_id=%d, time=%lums, timeout=%dms, " "tryCount=%u, RunningState=%u.", deviceId, streamId_, count, timeout, tryCount, device_->GetDevRunningState()); @@ -2955,20 +3021,19 @@ rtError_t Stream::WaitForTask(const uint32_t taskId, const bool isNeedWaitSyncCq COND_RETURN_WITH_NOLOG(error != RT_ERROR_NONE, error); TaskInfo submitTask = {}; - TaskInfo *tsk = &submitTask; + TaskInfo* tsk = &submitTask; error = ProcRecordTask(tsk); ERROR_RETURN(error, "Failed to submit create record task, stream_id=%d.", streamId_); // get logic cq bool isFastCq = false; - StreamSqCqManage * const stmSqCqManage = const_cast(device_->GetStreamSqCqManage()); + StreamSqCqManage* const stmSqCqManage = const_cast(device_->GetStreamSqCqManage()); COND_RETURN_ERROR_MSG_INNER(stmSqCqManage == nullptr, RT_ERROR_INVALID_VALUE, "Failed to get SqCqManager."); - error = stmSqCqManage->AllocLogicCq(static_cast(streamId_), - IsSteamNeedFastCq(), logicCqId, isFastCq); + error = stmSqCqManage->AllocLogicCq(static_cast(streamId_), IsSteamNeedFastCq(), logicCqId, isFastCq); COND_RETURN_ERROR(error != RT_ERROR_NONE, error, "alloc logic cq failed."); - EventRecordTaskInfo * const eventRecordTsk = &(tsk->u.eventRecordTaskInfo); + EventRecordTaskInfo* const eventRecordTsk = &(tsk->u.eventRecordTaskInfo); eventRecordTsk->waitCqflag = true; eventRecordTsk->waitCqId = static_cast(logicCqId); eventRecordTsk->timeout = timeout; @@ -2983,16 +3048,17 @@ rtError_t Stream::WaitForTask(const uint32_t taskId, const bool isNeedWaitSyncCq if (error == RT_ERROR_STREAM_SYNC_TIMEOUT) { return error; } - COND_PROC_RETURN_ERROR(error != RT_ERROR_NONE, error, - (void)device_->GetTaskFactory()->Recycle(tsk), "Failed to submit EventRecordTask."); + COND_PROC_RETURN_ERROR( + error != RT_ERROR_NONE, error, (void)device_->GetTaskFactory()->Recycle(tsk), + "Failed to submit EventRecordTask."); - error = stmSqCqManage->FreeLogicCqByThread(static_cast(streamId_)); + error = stmSqCqManage->FreeLogicCqByThread(static_cast(streamId_)); COND_RETURN_ERROR_MSG_INNER(error != RT_ERROR_NONE, error, "Failed to free logical cq."); return error; } -void Stream::ReportErrorMessage(const uint32_t errCode, const std::string &errMsg) +void Stream::ReportErrorMessage(const uint32_t errCode, const std::string& errMsg) { if (errorMsg_.size() < ERROR_MESSAGE_MAX_SIZE) { errorMsgLock_.lock(); @@ -3006,18 +3072,20 @@ rtError_t Stream::AllocExecutedTimesSvm() { rtError_t error = RT_ERROR_NONE; if (Runtime::Instance()->ChipIsHaveStars()) { - Runtime * const rtInstance = Runtime::Instance(); + Runtime* const rtInstance = Runtime::Instance(); const rtMemType_t memType = rtInstance->GetTsMemType(MEM_REQUEST_FEATURE_DEFAULT, sizeof(uint16_t)); - error = device_->Driver_()->DevMemAlloc(RtPtrToPtr(&executedTimesSvm_), sizeof(uint16_t), - memType, device_->Id_()); - COND_RETURN_ERROR_MSG_INNER((error != RT_ERROR_NONE) || (executedTimesSvm_ == nullptr), error, - "Failed to Allocate SVM, retCode=%#x.", error); + error = device_->Driver_()->DevMemAlloc( + RtPtrToPtr(&executedTimesSvm_), sizeof(uint16_t), memType, device_->Id_()); + COND_RETURN_ERROR_MSG_INNER( + (error != RT_ERROR_NONE) || (executedTimesSvm_ == nullptr), error, "Failed to Allocate SVM, retCode=%#x.", + error); RT_LOG(RT_LOG_INFO, "stream_id=%d.", streamId_); error = device_->Driver_()->MemSetSync(executedTimesSvm_, sizeof(uint16_t), 0xFFU, sizeof(uint16_t)); - COND_RETURN_ERROR(error != RT_ERROR_NONE, error, - "MemSetSync stream executed times SVM failed, retCode=%#x.", static_cast(error)); + COND_RETURN_ERROR( + error != RT_ERROR_NONE, error, "MemSetSync stream executed times SVM failed, retCode=%#x.", + static_cast(error)); } return error; } @@ -3032,8 +3100,8 @@ rtError_t Stream::FreeExecutedTimesSvm() } const rtError_t error = device_->Driver_()->DevMemFree(executedTimesSvm_, device_->Id_()); - COND_RETURN_ERROR(error != RT_ERROR_NONE, error, - "Free executedTimes SVM failed, mem free failed, retCode=%#x.", error); + COND_RETURN_ERROR( + error != RT_ERROR_NONE, error, "Free executedTimes SVM failed, mem free failed, retCode=%#x.", error); executedTimesSvm_ = nullptr; return RT_ERROR_NONE; } @@ -3042,10 +3110,10 @@ rtError_t Stream::SetSqRegVirtualAddrToDevice(uint64_t sqRegVirtualAddr) const { rtError_t error = RT_ERROR_NONE; if ((device_->GetSqVirtualArrBaseAddr_() != nullptr) && (sqRegVirtualAddr != 0ULL)) { - uint64_t *deviceMemForVirAddr = static_cast(device_->GetSqVirtualArrBaseAddr_()) + sqId_; - error = device_->Driver_()->MemCopySync(static_cast(deviceMemForVirAddr), sizeof(uint64_t), - static_cast(&sqRegVirtualAddr), sizeof(uint64_t), - RT_MEMCPY_HOST_TO_DEVICE); + uint64_t* deviceMemForVirAddr = static_cast(device_->GetSqVirtualArrBaseAddr_()) + sqId_; + error = device_->Driver_()->MemCopySync( + static_cast(deviceMemForVirAddr), sizeof(uint64_t), static_cast(&sqRegVirtualAddr), + sizeof(uint64_t), RT_MEMCPY_HOST_TO_DEVICE); } return error; } @@ -3056,7 +3124,7 @@ bool Stream::IsPersistentTaskFull() return (persistentTaskid_.size() >= device_->GetDevProperties().maxPersistTaskNum); } -void Stream::InsertPendingList(uint32_t hostTaskType, HostTaskBase *base) +void Stream::InsertPendingList(uint32_t hostTaskType, HostTaskBase* base) { const std::lock_guard hostTaskLock(hostTaskMutex_); hostTaskPendingList_[hostTaskType].push_back(base); @@ -3068,13 +3136,14 @@ rtError_t Stream::ExecPendingList(uint32_t hostTaskType) rtError_t retCode = RT_ERROR_NONE; rtError_t errorCode = RT_ERROR_NONE; - for (auto iter = hostTaskPendingList_[hostTaskType].begin(); - iter != hostTaskPendingList_[hostTaskType].end(); iter++) { + for (auto iter = hostTaskPendingList_[hostTaskType].begin(); iter != hostTaskPendingList_[hostTaskType].end(); + iter++) { retCode = (*iter)->WaitFinish(); if (retCode != RT_ERROR_NONE) { errorCode = retCode; - RT_LOG(RT_LOG_ERROR, "ExecPendingList result failed, hostTaskType = %d, retCode = %#x.", - hostTaskType, errorCode); + RT_LOG( + RT_LOG_ERROR, "ExecPendingList result failed, hostTaskType = %d, retCode = %#x.", hostTaskType, + errorCode); } DELETE_O(*iter); } @@ -3102,35 +3171,44 @@ void Stream::StarsShowStmDfxInfo(void) error = device_->Driver_()->GetSqHead(device_->Id_(), tsId, sqId, sqHead); if (error != RT_ERROR_NONE) { - RT_LOG(RT_LOG_ERROR, "Query sq head, device_id=%u, stream_id=%d, retCode=%#x", - device_->Id_(), Id_(), static_cast(error)); + RT_LOG( + RT_LOG_ERROR, "Query sq head, device_id=%u, stream_id=%d, retCode=%#x", device_->Id_(), Id_(), + static_cast(error)); return; } error = device_->Driver_()->GetSqTail(device_->Id_(), tsId, sqId, sqTail); if (error != RT_ERROR_NONE) { - RT_LOG(RT_LOG_ERROR, "Query sq tail failed, device_id=%u, stream_id=%d, retCode=%#x", - device_->Id_(), Id_(), static_cast(error)); + RT_LOG( + RT_LOG_ERROR, "Query sq tail failed, device_id=%u, stream_id=%d, retCode=%#x", device_->Id_(), Id_(), + static_cast(error)); return; } - RT_LOG(RT_LOG_EVENT, "Current sq head and tail info, device_id=%u, stream_id=%d, sqHead=%hu, sqTail=%hu", + RT_LOG( + RT_LOG_EVENT, "Current sq head and tail info, device_id=%u, stream_id=%d, sqHead=%hu, sqTail=%hu", device_->Id_(), Id_(), sqHead, sqTail); uint32_t headTaskId = UINT16_MAX; error = GetTaskIdByPos(sqHead, headTaskId); if (error == RT_ERROR_NONE) { - TaskInfo * const workTask = device_->GetTaskFactory()->GetTask(Id_(), static_cast(headTaskId)); + TaskInfo* const workTask = device_->GetTaskFactory()->GetTask(Id_(), static_cast(headTaskId)); if (workTask != nullptr) { - RT_LOG(RT_LOG_EVENT, "Current work task info, device_id=%u, stream_id=%d, task_id=%u, task_type=%u, " - "sqHead=%hu, sqTail=%hu", device_->Id_(), Id_(), workTask->id, workTask->type, sqHead, sqTail); + RT_LOG( + RT_LOG_EVENT, + "Current work task info, device_id=%u, stream_id=%d, task_id=%u, task_type=%u, " + "sqHead=%hu, sqTail=%hu", + device_->Id_(), Id_(), workTask->id, workTask->type, sqHead, sqTail); } } else { - RT_LOG(RT_LOG_ERROR, "Get task failed, device_id=%u, stream_id=%d, sqHead=%hu, sqTail=%hu, retCode=%#x", + RT_LOG( + RT_LOG_ERROR, "Get task failed, device_id=%u, stream_id=%d, sqHead=%hu, sqTail=%hu, retCode=%#x", device_->Id_(), Id_(), sqHead, sqTail, static_cast(error)); } - RT_LOG(RT_LOG_EVENT, "Stream res info, finishTaskId=%u, lastTaskId=%u, pendingNum=%u, " + RT_LOG( + RT_LOG_EVENT, + "Stream res info, finishTaskId=%u, lastTaskId=%u, pendingNum=%u, " "davinciTaskHead=%u, davinciTaskTail=%u, taskHead=%u, taskTail=%u, taskPosHead=%u, taskPosTail=%u,", finishTaskId_, lastTaskId_, pendingNum_.Value(), davinciTaskHead_, davinciTaskTail_, taskHead_, taskTail_, taskPosHead_.Value(), taskPosTail_.Value()); @@ -3147,18 +3225,20 @@ void Stream::StarsShowStmDfxInfo(void) for (uint32_t i = 0; i <= 5U; i++) { headIndex[i] = (headStart + i) % rtsqDepth; } - RT_LOG(RT_LOG_EVENT, "Task pos info for head, pos:taskId %u:%hu, %u:%hu, %u:%hu, %u:%hu, %u:%hu, %u:%hu", - headIndex[0U], posToTaskIdMap_[headIndex[0U]], headIndex[1U], posToTaskIdMap_[headIndex[1U]], - headIndex[2U], posToTaskIdMap_[headIndex[2U]], headIndex[3U], posToTaskIdMap_[headIndex[3U]], - headIndex[4U], posToTaskIdMap_[headIndex[4U]], headIndex[5U], posToTaskIdMap_[headIndex[5U]]); + RT_LOG( + RT_LOG_EVENT, "Task pos info for head, pos:taskId %u:%hu, %u:%hu, %u:%hu, %u:%hu, %u:%hu, %u:%hu", + headIndex[0U], posToTaskIdMap_[headIndex[0U]], headIndex[1U], posToTaskIdMap_[headIndex[1U]], headIndex[2U], + posToTaskIdMap_[headIndex[2U]], headIndex[3U], posToTaskIdMap_[headIndex[3U]], headIndex[4U], + posToTaskIdMap_[headIndex[4U]], headIndex[5U], posToTaskIdMap_[headIndex[5U]]); for (uint32_t i = 0; i <= 5U; i++) { tailIndex[i] = (tailStart + i) % rtsqDepth; } - RT_LOG(RT_LOG_EVENT, "Task pos info for tail, pos:taskId %u:%hu, %u:%hu, %u:%hu, %u:%hu, %u:%hu, %u:%hu", - tailIndex[0U], posToTaskIdMap_[tailIndex[0U]], tailIndex[1U], posToTaskIdMap_[tailIndex[1U]], - tailIndex[2U], posToTaskIdMap_[tailIndex[2U]], tailIndex[3U], posToTaskIdMap_[tailIndex[3U]], - tailIndex[4U], posToTaskIdMap_[tailIndex[4U]], tailIndex[5U], posToTaskIdMap_[tailIndex[5U]]); + RT_LOG( + RT_LOG_EVENT, "Task pos info for tail, pos:taskId %u:%hu, %u:%hu, %u:%hu, %u:%hu, %u:%hu, %u:%hu", + tailIndex[0U], posToTaskIdMap_[tailIndex[0U]], tailIndex[1U], posToTaskIdMap_[tailIndex[1U]], tailIndex[2U], + posToTaskIdMap_[tailIndex[2U]], tailIndex[3U], posToTaskIdMap_[tailIndex[3U]], tailIndex[4U], + posToTaskIdMap_[tailIndex[4U]], tailIndex[5U], posToTaskIdMap_[tailIndex[5U]]); if (taskResMang_ != nullptr) { taskResMang_->ShowDfxInfo(); @@ -3171,21 +3251,24 @@ void Stream::DcShowStmDfxInfo(void) uint32_t headTaskId = UINT16_MAX; const rtError_t error = GetLastTaskIdFromCqShm(headTaskId); if (error == RT_ERROR_NONE) { - TaskInfo *const workTask = device_->GetTaskFactory()->GetTask(Id_(), static_cast(headTaskId)); + TaskInfo* const workTask = device_->GetTaskFactory()->GetTask(Id_(), static_cast(headTaskId)); if (workTask != nullptr) { - RT_LOG(RT_LOG_EVENT, - "Current work task info, device_id=%u, stream_id=%d, task_id=%u, task_type=%u", + RT_LOG( + RT_LOG_EVENT, "Current work task info, device_id=%u, stream_id=%d, task_id=%u, task_type=%u", device_->Id_(), Id_(), workTask->id, workTask->type); } } else { - RT_LOG(RT_LOG_ERROR, - "Get task failed, device_id=%u, stream_id=%d, retCode=%#x", - device_->Id_(), Id_(), static_cast(error)); + RT_LOG( + RT_LOG_ERROR, "Get task failed, device_id=%u, stream_id=%d, retCode=%#x", device_->Id_(), Id_(), + static_cast(error)); } const uint32_t streamShmTaskId = device_->GetTaskIdFromStreamShmTaskId(static_cast(streamId_)); - RT_LOG(RT_LOG_EVENT, "Stream res info, finishTaskId=%u, lastTaskId=%u, pendingNum=%u, davinciTaskHead=%u, " - "davinciTaskTail=%u, taskHead=%u, taskTail=%u, headTaskId=%u, streamShmTaskId=%u", finishTaskId_, lastTaskId_, - pendingNum_.Value(), davinciTaskHead_, davinciTaskTail_, taskHead_, taskTail_, headTaskId, streamShmTaskId); + RT_LOG( + RT_LOG_EVENT, + "Stream res info, finishTaskId=%u, lastTaskId=%u, pendingNum=%u, davinciTaskHead=%u, " + "davinciTaskTail=%u, taskHead=%u, taskTail=%u, headTaskId=%u, streamShmTaskId=%u", + finishTaskId_, lastTaskId_, pendingNum_.Value(), davinciTaskHead_, davinciTaskTail_, taskHead_, taskTail_, + headTaskId, streamShmTaskId); if ((taskPublicBuff_ != nullptr) && taskPublicBuffSize_ > 0) { uint32_t taskPublicHeadIndex[SHOW_DFX_INFO_TASK_NUM] = {0}; @@ -3198,23 +3281,21 @@ void Stream::DcShowStmDfxInfo(void) taskPublicTailIndex[i] = (taskPublicTailStart + i) % taskPublicBuffSize_; } // taskPublicBuffer_ : 保存非davinci类型的task，回收时在主线程回收 - RT_LOG(RT_LOG_EVENT, - "Task pos info for task public head, pos:taskId %u:%u, %u:%u, %u:%u, %u:%u, %u:%u, %u:%u", - taskPublicHeadIndex[0U], taskPublicBuff_[taskPublicHeadIndex[0U]], - taskPublicHeadIndex[1U], taskPublicBuff_[taskPublicHeadIndex[1U]], - taskPublicHeadIndex[2U], taskPublicBuff_[taskPublicHeadIndex[2U]], - taskPublicHeadIndex[3U], taskPublicBuff_[taskPublicHeadIndex[3U]], - taskPublicHeadIndex[4U], taskPublicBuff_[taskPublicHeadIndex[4U]], - taskPublicHeadIndex[5U], taskPublicBuff_[taskPublicHeadIndex[5U]]); - - RT_LOG(RT_LOG_EVENT, - "Task pos info for task public tail, pos:taskId %u:%u, %u:%u, %u:%u, %u:%u, %u:%u, %u:%u", - taskPublicTailIndex[0U], taskPublicBuff_[taskPublicTailIndex[0U]], - taskPublicTailIndex[1U], taskPublicBuff_[taskPublicTailIndex[1U]], - taskPublicTailIndex[2U], taskPublicBuff_[taskPublicTailIndex[2U]], - taskPublicTailIndex[3U], taskPublicBuff_[taskPublicTailIndex[3U]], - taskPublicTailIndex[4U], taskPublicBuff_[taskPublicTailIndex[4U]], - taskPublicTailIndex[5U], taskPublicBuff_[taskPublicTailIndex[5U]]); + RT_LOG( + RT_LOG_EVENT, "Task pos info for task public head, pos:taskId %u:%u, %u:%u, %u:%u, %u:%u, %u:%u, %u:%u", + taskPublicHeadIndex[0U], taskPublicBuff_[taskPublicHeadIndex[0U]], taskPublicHeadIndex[1U], + taskPublicBuff_[taskPublicHeadIndex[1U]], taskPublicHeadIndex[2U], taskPublicBuff_[taskPublicHeadIndex[2U]], + taskPublicHeadIndex[3U], taskPublicBuff_[taskPublicHeadIndex[3U]], taskPublicHeadIndex[4U], + taskPublicBuff_[taskPublicHeadIndex[4U]], taskPublicHeadIndex[5U], + taskPublicBuff_[taskPublicHeadIndex[5U]]); + + RT_LOG( + RT_LOG_EVENT, "Task pos info for task public tail, pos:taskId %u:%u, %u:%u, %u:%u, %u:%u, %u:%u, %u:%u", + taskPublicTailIndex[0U], taskPublicBuff_[taskPublicTailIndex[0U]], taskPublicTailIndex[1U], + taskPublicBuff_[taskPublicTailIndex[1U]], taskPublicTailIndex[2U], taskPublicBuff_[taskPublicTailIndex[2U]], + taskPublicTailIndex[3U], taskPublicBuff_[taskPublicTailIndex[3U]], taskPublicTailIndex[4U], + taskPublicBuff_[taskPublicTailIndex[4U]], taskPublicTailIndex[5U], + taskPublicBuff_[taskPublicTailIndex[5U]]); } if ((davinciTaskList_ != nullptr) && (davinciTaskListSize_ > 0)) { uint32_t davinciTaskHeadIndex[SHOW_DFX_INFO_TASK_NUM] = {0}; @@ -3226,23 +3307,23 @@ void Stream::DcShowStmDfxInfo(void) davinciTaskTailIndex[i] = (davinciTaskTailStart + i) % davinciTaskListSize_; } // davinciTaskList_ : 保存davinci类型的task，回收时在回收线程回收 - RT_LOG(RT_LOG_EVENT, - "Task pos info for davinci task head, pos:taskId %u:%u, %u:%u, %u:%u, %u:%u, %u:%u, %u:%u", - davinciTaskHeadIndex[0U], davinciTaskList_[davinciTaskHeadIndex[0U]], - davinciTaskHeadIndex[1U], davinciTaskList_[davinciTaskHeadIndex[1U]], - davinciTaskHeadIndex[2U], davinciTaskList_[davinciTaskHeadIndex[2U]], - davinciTaskHeadIndex[3U], davinciTaskList_[davinciTaskHeadIndex[3U]], - davinciTaskHeadIndex[4U], davinciTaskList_[davinciTaskHeadIndex[4U]], - davinciTaskHeadIndex[5U], davinciTaskList_[davinciTaskHeadIndex[5U]]); - - RT_LOG(RT_LOG_EVENT, - "Task pos info for davinci task tail, pos:taskId %u:%u, %u:%u, %u:%u, %u:%u, %u:%u, %u:%u", - davinciTaskTailIndex[0U], davinciTaskList_[davinciTaskTailIndex[0U]], - davinciTaskTailIndex[1U], davinciTaskList_[davinciTaskTailIndex[1U]], - davinciTaskTailIndex[2U], davinciTaskList_[davinciTaskTailIndex[2U]], - davinciTaskTailIndex[3U], davinciTaskList_[davinciTaskTailIndex[3U]], - davinciTaskTailIndex[4U], davinciTaskList_[davinciTaskTailIndex[4U]], - davinciTaskTailIndex[5U], davinciTaskList_[davinciTaskTailIndex[5U]]); + RT_LOG( + RT_LOG_EVENT, "Task pos info for davinci task head, pos:taskId %u:%u, %u:%u, %u:%u, %u:%u, %u:%u, %u:%u", + davinciTaskHeadIndex[0U], davinciTaskList_[davinciTaskHeadIndex[0U]], davinciTaskHeadIndex[1U], + davinciTaskList_[davinciTaskHeadIndex[1U]], davinciTaskHeadIndex[2U], + davinciTaskList_[davinciTaskHeadIndex[2U]], davinciTaskHeadIndex[3U], + davinciTaskList_[davinciTaskHeadIndex[3U]], davinciTaskHeadIndex[4U], + davinciTaskList_[davinciTaskHeadIndex[4U]], davinciTaskHeadIndex[5U], + davinciTaskList_[davinciTaskHeadIndex[5U]]); + + RT_LOG( + RT_LOG_EVENT, "Task pos info for davinci task tail, pos:taskId %u:%u, %u:%u, %u:%u, %u:%u, %u:%u, %u:%u", + davinciTaskTailIndex[0U], davinciTaskList_[davinciTaskTailIndex[0U]], davinciTaskTailIndex[1U], + davinciTaskList_[davinciTaskTailIndex[1U]], davinciTaskTailIndex[2U], + davinciTaskList_[davinciTaskTailIndex[2U]], davinciTaskTailIndex[3U], + davinciTaskList_[davinciTaskTailIndex[3U]], davinciTaskTailIndex[4U], + davinciTaskList_[davinciTaskTailIndex[4U]], davinciTaskTailIndex[5U], + davinciTaskList_[davinciTaskTailIndex[5U]]); } if (taskResMang_ != nullptr) { taskResMang_->ShowDfxInfo(); @@ -3258,7 +3339,7 @@ void Stream::ShowStmDfxInfo(void) } } -void Stream::StarsStmDfxCheck(uint64_t &beginCnt, uint64_t &endCnt, uint16_t &checkCount) +void Stream::StarsStmDfxCheck(uint64_t& beginCnt, uint64_t& endCnt, uint16_t& checkCount) { if (checkCount >= TASK_SENDING_WAIT_CHECK_COUNT) { return; @@ -3267,13 +3348,13 @@ void Stream::StarsStmDfxCheck(uint64_t &beginCnt, uint64_t &endCnt, uint16_t &ch if (beginCnt == 0ULL) { mmTimespec beginTimeSpec = mmGetTickCount(); beginCnt = static_cast(beginTimeSpec.tv_sec) * RT_MS_PER_S + - static_cast(beginTimeSpec.tv_nsec) / RT_MS_TO_NS; + static_cast(beginTimeSpec.tv_nsec) / RT_MS_TO_NS; return; } mmTimespec endTimeSpec = mmGetTickCount(); endCnt = static_cast(endTimeSpec.tv_sec) * RT_MS_PER_S + - static_cast(endTimeSpec.tv_nsec) / RT_MS_TO_NS; + static_cast(endTimeSpec.tv_nsec) / RT_MS_TO_NS; const uint64_t spendTime = (endCnt > beginCnt) ? (endCnt - beginCnt) : 0ULL; @@ -3284,7 +3365,7 @@ void Stream::StarsStmDfxCheck(uint64_t &beginCnt, uint64_t &endCnt, uint16_t &ch } } -void Stream::StmDfxCheck(uint64_t &beginCnt, uint64_t &endCnt, uint16_t &checkCount) +void Stream::StmDfxCheck(uint64_t& beginCnt, uint64_t& endCnt, uint16_t& checkCount) { if (checkCount >= TASK_SENDING_WAIT_CHECK_COUNT) { return; @@ -3293,13 +3374,13 @@ void Stream::StmDfxCheck(uint64_t &beginCnt, uint64_t &endCnt, uint16_t &checkCo if (beginCnt == 0ULL) { mmTimespec beginTimeSpec = mmGetTickCount(); beginCnt = static_cast(beginTimeSpec.tv_sec) * RT_MS_PER_S + - static_cast(beginTimeSpec.tv_nsec) / RT_MS_TO_NS; + static_cast(beginTimeSpec.tv_nsec) / RT_MS_TO_NS; return; } mmTimespec endTimeSpec = mmGetTickCount(); - endCnt = static_cast(endTimeSpec.tv_sec) * 1000UL + - static_cast(endTimeSpec.tv_nsec) / RT_MS_TO_NS; + endCnt = + static_cast(endTimeSpec.tv_sec) * 1000UL + static_cast(endTimeSpec.tv_nsec) / RT_MS_TO_NS; const uint64_t spendTime = (endCnt > beginCnt) ? (endCnt - beginCnt) : 0ULL; @@ -3311,7 +3392,7 @@ void Stream::StmDfxCheck(uint64_t &beginCnt, uint64_t &endCnt, uint16_t &checkCo } rtError_t Stream::PrintStmDfxAndCheckDevice( - uint64_t &beginCnt, uint64_t &endCnt, uint16_t &checkCount, uint32_t tryCount) + uint64_t& beginCnt, uint64_t& endCnt, uint16_t& checkCount, uint32_t tryCount) { constexpr uint16_t perDetectTimes = 1000U; if ((tryCount % perDetectTimes) == 0) { @@ -3327,7 +3408,7 @@ rtError_t Stream::PrintStmDfxAndCheckDevice( } // taskPersistentTail_/taskPosTail_ save the postion of rtsq tail -rtError_t Stream::StarsAddTaskToStream(TaskInfo * const tsk, const uint32_t sendSqeNum) +rtError_t Stream::StarsAddTaskToStream(TaskInfo* const tsk, const uint32_t sendSqeNum) { NULL_PTR_RETURN_MSG(tsk, RT_ERROR_TASK_NULL); const bool bind = GetBindFlag(); @@ -3341,21 +3422,25 @@ rtError_t Stream::StarsAddTaskToStream(TaskInfo * const tsk, const uint32_t send if (bind) { // If model stream is already full, return STREAM_FULL. PendingNum add 1 in TaskSubmited. Because the task will // not be sent, pendingNum sub 1 is performed. - COND_PROC_RETURN_AND_MSG_OUTER(posTail + sendSqeNum >= rtsqDepth, RT_ERROR_STREAM_FULL, ErrorCode::EE1019, pendingNum_.Sub(1), - "Adding task to stream", "The model stream is full, stream_id=" + std::to_string(streamId_) + ", task_id=" - + std::to_string(tsk->id) + ", posTail=" + std::to_string(posTail) + ", sendSqeNum=" - + std::to_string(sendSqeNum) + ", rtsqDepth=" + std::to_string(rtsqDepth)); + COND_PROC_RETURN_AND_MSG_OUTER( + posTail + sendSqeNum >= rtsqDepth, RT_ERROR_STREAM_FULL, ErrorCode::EE1019, pendingNum_.Sub(1), + "Adding task to stream", + "The model stream is full, stream_id=" + std::to_string(streamId_) + + ", task_id=" + std::to_string(tsk->id) + ", posTail=" + std::to_string(posTail) + + ", sendSqeNum=" + std::to_string(sendSqeNum) + ", rtsqDepth=" + std::to_string(rtsqDepth)); const rtError_t ret = PackingTaskGroup(tsk, static_cast(streamId_)); - COND_PROC_RETURN_ERROR_MSG_INNER(ret != RT_ERROR_NONE, ret, SetTaskGroupErrCode(ret), - "Pack task group failed, stream_id=%d, task_id=%hu.", streamId_, tsk->id); + COND_PROC_RETURN_ERROR_MSG_INNER( + ret != RT_ERROR_NONE, ret, SetTaskGroupErrCode(ret), "Pack task group failed, stream_id=%d, task_id=%hu.", + streamId_, tsk->id); taskPersistentTail_.Set(newPosTail); delayRecycleTaskid_.push_back(tsk->id); - Model *model = tsk->stream->Model_(); + Model* model = tsk->stream->Model_(); if ((model != nullptr) && (model->GetModelType() == RT_MODEL_CAPTURE_MODEL)) { - tsk->modelSeqId = dynamic_cast(model)->GenerateSeqId(); - RT_LOG(RT_LOG_INFO, "device_id=%u, stream_id=%d, task_id=%hu, sequence id=%u.", - tsk->stream->Device_()->Id_(), streamId_, tsk->id, tsk->modelSeqId); + tsk->modelSeqId = dynamic_cast(model)->GenerateSeqId(); + RT_LOG( + RT_LOG_INFO, "device_id=%u, stream_id=%d, task_id=%hu, sequence id=%u.", tsk->stream->Device_()->Id_(), + streamId_, tsk->id, tsk->modelSeqId); } } else { const uint32_t posHead = bind ? taskPersistentHead_.Value() : taskPosHead_.Value(); @@ -3396,9 +3481,10 @@ rtError_t Stream::StarsAddTaskToStreamForModelUpdate(TaskInfo* const tsk, const // If model stream is already full, return STREAM_FULL. COND_RETURN_AND_MSG_OUTER( (posTail + sendSqeNum >= rtsqDepth), RT_ERROR_STREAM_FULL, ErrorCode::EE1019, - "Adding task to stream for model update", "The model stream is full, stream_id=" + std::to_string(streamId_) + ", task_id=" - + std::to_string(tsk->id) + ", posTail=" + std::to_string(posTail) + ", sendSqeNum=" - + std::to_string(sendSqeNum) + ", rtsqDepth=" + std::to_string(rtsqDepth)); + "Adding task to stream for model update", + "The model stream is full, stream_id=" + std::to_string(streamId_) + ", task_id=" + std::to_string(tsk->id) + + ", posTail=" + std::to_string(posTail) + ", sendSqeNum=" + std::to_string(sendSqeNum) + + ", rtsqDepth=" + std::to_string(rtsqDepth)); taskPersistentTail_.Set(newPosTail); delayRecycleTaskid_.push_back(tsk->id); @@ -3433,15 +3519,18 @@ rtError_t Stream::HandleTaskUpdate( auto ret = memcpy_s( RtPtrToPtr(sqeBufferBackup + sizeof(rtStarsSqe_t) * workTask->pos), sendSqeNum * sizeof(rtStarsSqe_t), RtPtrToPtr(cmdLocal.cmdBuf.u.starsSqe), sendSqeNum * sizeof(rtStarsSqe_t)); - COND_RETURN_ERROR_MSG_INNER(ret != EOK, RT_ERROR_INVALID_VALUE, - "Failed to call memcpy_s, dest=%p, dest_max=%zu, src=%p, count=%zu, retCode=%d, device_id=%u, stream_id=%d, task_id=%hu, task_type=%d(%s).", + COND_RETURN_ERROR_MSG_INNER( + ret != EOK, RT_ERROR_INVALID_VALUE, + "Failed to call memcpy_s, dest=%p, dest_max=%zu, src=%p, count=%zu, retCode=%d, device_id=%u, stream_id=%d, " + "task_id=%hu, task_type=%d(%s).", sqeBufferBackup + sizeof(rtStarsSqe_t) * workTask->pos, sendSqeNum * sizeof(rtStarsSqe_t), - cmdLocal.cmdBuf.u.starsSqe, sendSqeNum * sizeof(rtStarsSqe_t), ret, device_->Id_(), streamId_, workTask->id, workTask->type, workTask->typeName); + cmdLocal.cmdBuf.u.starsSqe, sendSqeNum * sizeof(rtStarsSqe_t), ret, device_->Id_(), streamId_, workTask->id, + workTask->type, workTask->typeName); Complete(workTask, device_->Id_()); RT_LOG( - RT_LOG_INFO, "update task finish, stream_id=%d, task_id=%hu, task_type=%d(%s).", - streamId_, workTask->id, workTask->type, workTask->typeName); + RT_LOG_INFO, "update task finish, stream_id=%d, task_id=%hu, task_type=%d(%s).", streamId_, workTask->id, + workTask->type, workTask->typeName); return RT_ERROR_NONE; } @@ -3457,7 +3546,8 @@ rtError_t Stream::HandleTaskDisable(TaskInfo* workTask, CaptureModel* model) return RT_ERROR_NONE; } -rtError_t Stream::HandleTaskDefault(TaskInfo* workTask, CaptureModel* model, uint8_t* sqeBufferBackup, uint32_t sendSqeNum) +rtError_t Stream::HandleTaskDefault( + TaskInfo* workTask, CaptureModel* model, uint8_t* sqeBufferBackup, uint32_t sendSqeNum) { model->SetKernelTaskId(static_cast(workTask->id), streamId_); // 获取老的sqe @@ -3475,10 +3565,13 @@ rtError_t Stream::HandleTaskDefault(TaskInfo* workTask, CaptureModel* model, uin auto ret = memcpy_s( RtPtrToPtr(sqeBufferBackup + sizeof(rtStarsSqe_t) * workTask->pos), sendSqeNum * sizeof(rtStarsSqe_t), RtPtrToPtr(oldhostSqeAddr), sendSqeNum * sizeof(rtStarsSqe_t)); - COND_RETURN_ERROR_MSG_INNER(ret != EOK, RT_ERROR_INVALID_VALUE, - "Failed to call memcpy_s, dest=%p, dest_max=%zu, src=%p, count=%zu, retCode=%d, device_id=%u, stream_id=%d, task_id=%hu, task_type=%d(%s).", - sqeBufferBackup + sizeof(rtStarsSqe_t) * workTask->pos, sendSqeNum * sizeof(rtStarsSqe_t), - oldhostSqeAddr, sendSqeNum * sizeof(rtStarsSqe_t), ret, device_->Id_(), streamId_, workTask->id, workTask->type, workTask->typeName); + COND_RETURN_ERROR_MSG_INNER( + ret != EOK, RT_ERROR_INVALID_VALUE, + "Failed to call memcpy_s, dest=%p, dest_max=%zu, src=%p, count=%zu, retCode=%d, device_id=%u, stream_id=%d, " + "task_id=%hu, task_type=%d(%s).", + sqeBufferBackup + sizeof(rtStarsSqe_t) * workTask->pos, sendSqeNum * sizeof(rtStarsSqe_t), oldhostSqeAddr, + sendSqeNum * sizeof(rtStarsSqe_t), ret, device_->Id_(), streamId_, workTask->id, workTask->type, + workTask->typeName); RT_LOG( RT_LOG_INFO, "handle default task finish, stream_id=%d, task_id=%hu, task_type=%d(%s).", streamId_, workTask->id, workTask->type, workTask->typeName); @@ -3493,7 +3586,8 @@ rtError_t Stream::UpdateAllPersistentTask() taskPersistentTail_.Set(0U); errno_t ret = memset_s(posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0XFF, posToTaskIdMapSize_ * sizeof(uint16_t)); - COND_RETURN_ERROR_MSG_INNER(ret != EOK, RT_ERROR_STREAM_NEW, + COND_RETURN_ERROR_MSG_INNER( + ret != EOK, RT_ERROR_STREAM_NEW, "Failed to call memset_s to set posToTaskIdMap_, dest=%p, dest_max=%zu, c=0xFF, count=%zu, retCode=%d.", posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), posToTaskIdMapSize_ * sizeof(uint16_t), ret); Model* mdl = Model_(); @@ -3504,13 +3598,14 @@ rtError_t Stream::UpdateAllPersistentTask() uint32_t totalSendSqeNum = 0U; rtError_t error = RT_ERROR_NONE; - // sqAddr还回池子，并恢复为默认值，防止执行后再次更新模型执行时，SQE个数增加(例如kernel->valueWait 4个)并跨档导致更新失败 + // sqAddr还回池子，并恢复为默认值，防止执行后再次更新模型执行时，SQE个数增加(例如kernel->valueWait + // 4个)并跨档导致更新失败 if (sqAddr_ != 0U) { - SqAddrMemoryOrder *sqAddrMemoryManage = Device_()->GetSqAddrMemoryManage(); + SqAddrMemoryOrder* sqAddrMemoryManage = Device_()->GetSqAddrMemoryManage(); if (sqAddrMemoryManage != nullptr) { - error = sqAddrMemoryManage->FreeSqAddr(RtValueToPtr(sqAddr_), sqMemOrderType_); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, - "Free sq addr failed, streamId=%d, ret=%#x.", streamId_, error); + error = sqAddrMemoryManage->FreeSqAddr(RtValueToPtr(sqAddr_), sqMemOrderType_); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, "Free sq addr failed, streamId=%d, ret=%#x.", streamId_, error); SetSqBaseAddr(0ULL); SetSqDepth(STREAM_SQ_MAX_DEPTH); } @@ -3522,13 +3617,15 @@ rtError_t Stream::UpdateAllPersistentTask() const uint32_t sendSqeNum = GetSendSqeNum(workTask); COND_RETURN_ERROR_MSG_INNER( sendSqeNum > SQE_NUM_PER_STARS_TASK_MAX, RT_ERROR_INVALID_VALUE, - "Value %u of sendSqeNum cannot be greater than the maximum number (%u) of SQEs allowed by the task. task_id=%hu, task_type=%d(%s).", + "Value %u of sendSqeNum cannot be greater than the maximum number (%u) of SQEs allowed by the task. " + "task_id=%hu, task_type=%d(%s).", sendSqeNum, SQE_NUM_PER_STARS_TASK_MAX, workTask->id, workTask->type, workTask->typeName); if (workTask->updateFlag == RT_TASK_UPDATE || workTask->updateFlag == RT_TASK_KEEP) { COND_RETURN_AND_MSG_OUTER( (totalSendSqeNum + sendSqeNum) >= STREAM_SQ_MAX_DEPTH, RT_ERROR_STREAM_FULL, ErrorCode::EE1019, - "Updating all persistent tasks", "The total number of SQEs " + std::to_string(totalSendSqeNum + sendSqeNum) - + " cannot be greater than or equal to the SQ depth " + std::to_string(STREAM_SQ_MAX_DEPTH)); + "Updating all persistent tasks", + "The total number of SQEs " + std::to_string(totalSendSqeNum + sendSqeNum) + + " cannot be greater than or equal to the SQ depth " + std::to_string(STREAM_SQ_MAX_DEPTH)); } switch (workTask->updateFlag) { case RT_TASK_UPDATE: @@ -3566,10 +3663,12 @@ rtError_t Stream::UpdateAllPersistentTask() ret = memcpy_s( RtPtrToPtr(sqeBuffer_), totalSendSqeNum * sizeof(rtStarsSqe_t), sqeBufferBackup.get(), totalSendSqeNum * sizeof(rtStarsSqe_t)); - COND_RETURN_ERROR_MSG_INNER(ret != EOK, RT_ERROR_STREAM_NEW, - "Failed to call memcpy_s to copy sqebuffer, dest=%p, dest_max=%zu, src=%p, count=%zu, retCode=%d, device_id=%u, stream_id=%d, totalSendSqeNum=%u.", - sqeBuffer_, totalSendSqeNum * sizeof(rtStarsSqe_t), - sqeBufferBackup.get(), totalSendSqeNum * sizeof(rtStarsSqe_t), ret, device_->Id_(), streamId_, totalSendSqeNum); + COND_RETURN_ERROR_MSG_INNER( + ret != EOK, RT_ERROR_STREAM_NEW, + "Failed to call memcpy_s to copy sqebuffer, dest=%p, dest_max=%zu, src=%p, count=%zu, retCode=%d, " + "device_id=%u, stream_id=%d, totalSendSqeNum=%u.", + sqeBuffer_, totalSendSqeNum * sizeof(rtStarsSqe_t), sqeBufferBackup.get(), + totalSendSqeNum * sizeof(rtStarsSqe_t), ret, device_->Id_(), streamId_, totalSendSqeNum); taskPersistentHead_.Set(taskPersistentTail_.Value()); } else { @@ -3657,7 +3756,6 @@ void Stream::UpdateTaskPosHead(const uint32_t sqPos, const uint32_t sqeNum) return; } - rtError_t Stream::TryDelPublicRecordedTask(const uint16_t tailTaskId) { if (taskPublicBuffSize_ == 0U) { @@ -3669,27 +3767,30 @@ rtError_t Stream::TryDelPublicRecordedTask(const uint16_t tailTaskId) const uint32_t fixTaskId = taskPublicBuff_[taskHead_ % taskPublicBuffSize_]; const uint16_t relTaskId = static_cast(fixTaskId & 0xFFFFU); if (TASK_ID_GT(relTaskId, tailTaskId)) { - RT_LOG(RT_LOG_DEBUG, "delTaskId is larger than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u, " - "head=%u, tail=%u", streamId_, static_cast(tailTaskId), static_cast(relTaskId), - taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, + "delTaskId is larger than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u, " + "head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(relTaskId), taskHead_, taskTail_); return RT_ERROR_STREAM_INVALID; } taskHead_ = ((taskHead_ + 1U) % taskPublicBuffSize_); - RT_LOG(RT_LOG_DEBUG, "del public task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), static_cast(relTaskId), - taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, "del public task from stream, stream_id=%d, tailTaskId=%u, delTaskId=%u, head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(relTaskId), taskHead_, taskTail_); finishTaskId_ = relTaskId; return RT_ERROR_NONE; } else { - RT_LOG(RT_LOG_DEBUG, "public task list null, stream_id=%d, task_id=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, "public task list null, stream_id=%d, task_id=%u, head=%u, tail=%u", streamId_, + static_cast(tailTaskId), taskHead_, taskTail_); return RT_ERROR_STREAM_EMPTY; } } -rtError_t Stream::StarsTryDelRecordedTask(const TaskInfo * const workTask, const bool isTaskBind, - const uint16_t tailTaskId) +rtError_t Stream::StarsTryDelRecordedTask( + const TaskInfo* const workTask, const bool isTaskBind, const uint16_t tailTaskId) { if (!isTaskBind) { return TryDelPublicRecordedTask(tailTaskId); @@ -3704,19 +3805,20 @@ rtError_t Stream::StarsTryDelRecordedTask(const TaskInfo * const workTask, const const uint32_t rtsqDepth = GetSqDepth(); taskPersistentHead_.Set((workTask->pos + 1) % rtsqDepth); - RT_LOG(RT_LOG_INFO, "del persistent task, stream_id=%d, tailTaskId=%u, delTaskId=%hu, head=%hu, tail=%u", - streamId_, static_cast(tailTaskId), delTaskId, - workTask->pos, taskPersistentTail_.Value()); + RT_LOG( + RT_LOG_INFO, "del persistent task, stream_id=%d, tailTaskId=%u, delTaskId=%hu, head=%hu, tail=%u", + streamId_, static_cast(tailTaskId), delTaskId, workTask->pos, taskPersistentTail_.Value()); return RT_ERROR_NONE; } else { - RT_LOG(RT_LOG_ERROR, "Task persistent buff null, stream_id=%d, task_id=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), workTask->pos, taskPersistentTail_.Value()); + RT_LOG( + RT_LOG_ERROR, "Task persistent buff null, stream_id=%d, task_id=%u, head=%u, tail=%u", streamId_, + static_cast(tailTaskId), workTask->pos, taskPersistentTail_.Value()); return RT_ERROR_STREAM_EMPTY; } } -rtError_t Stream::StarsGetPublicTaskHead(TaskInfo *workTask, const bool isTaskBind, const uint16_t tailTaskId, - uint16_t * const delTaskId) +rtError_t Stream::StarsGetPublicTaskHead( + TaskInfo* workTask, const bool isTaskBind, const uint16_t tailTaskId, uint16_t* const delTaskId) { NULL_PTR_RETURN_MSG(delTaskId, RT_ERROR_TASK_NULL); @@ -3726,17 +3828,21 @@ rtError_t Stream::StarsGetPublicTaskHead(TaskInfo *workTask, const bool isTaskBi const uint32_t fixTaskId = taskPublicBuff_[taskHead_ % taskPublicBuffSize_]; const uint16_t relTaskId = static_cast(fixTaskId & 0xFFFFU); if (TASK_ID_GT(relTaskId, tailTaskId)) { - RT_LOG(RT_LOG_DEBUG, "delTaskId is larger than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u, " - "head=%u, tail=%u", streamId_, static_cast(tailTaskId), static_cast(relTaskId), - taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, + "delTaskId is larger than tailTaskId, stream_id=%d, tailTaskId=%u, relTaskId=%u, " + "head=%u, tail=%u", + streamId_, static_cast(tailTaskId), static_cast(relTaskId), taskHead_, + taskTail_); return RT_ERROR_STREAM_INVALID; } *delTaskId = relTaskId; return RT_ERROR_NONE; } else { - RT_LOG(RT_LOG_DEBUG, "public task list null, stream_id=%d, task_id=%u, head=%u, tail=%u", - streamId_, static_cast(tailTaskId), taskHead_, taskTail_); + RT_LOG( + RT_LOG_DEBUG, "public task list null, stream_id=%d, task_id=%u, head=%u, tail=%u", streamId_, + static_cast(tailTaskId), taskHead_, taskTail_); return RT_ERROR_STREAM_EMPTY; } } @@ -3748,10 +3854,12 @@ rtError_t Stream::StarsGetPublicTaskHead(TaskInfo *workTask, const bool isTaskBi *delTaskId = static_cast((finishTaskId_ + 1U) % MAX_UINT16_NUM); return RT_ERROR_NONE; } else { - RT_LOG(RT_LOG_DEBUG, "Task persistent buff null, stream_id=%d, task_id=%u, head=%u, tail=%u, " + RT_LOG( + RT_LOG_DEBUG, + "Task persistent buff null, stream_id=%d, task_id=%u, head=%u, tail=%u, " "finishTaskId=%u, endTaskId=%hu", - streamId_, static_cast(tailTaskId), workTask->pos, taskPersistentTail_.Value(), - finishTaskId_, tailTaskId); + streamId_, static_cast(tailTaskId), workTask->pos, taskPersistentTail_.Value(), finishTaskId_, + tailTaskId); return RT_ERROR_STREAM_EMPTY; } } @@ -3762,20 +3870,23 @@ rtError_t Stream::ModelWaitForTask(const uint32_t taskId, const bool isNeedWaitS uint16_t sqTail = 0U; const uint32_t devId = device_->Id_(); const uint32_t tsId = device_->DevGetTsId(); - TaskInfo * const preTask = device_->GetTaskFactory()->GetTask(streamId_, static_cast(taskId)); + TaskInfo* const preTask = device_->GetTaskFactory()->GetTask(streamId_, static_cast(taskId)); while (!isNeedWaitSyncCq) { - COND_RETURN_ERROR_MSG_INNER((device_->GetDevRunningState() == static_cast(DEV_RUNNING_DOWN)), - RT_ERROR_DRV_ERR, "Device %u is unavailable, stream_id=%u.", device_->Id_(), streamId_); + COND_RETURN_ERROR_MSG_INNER( + (device_->GetDevRunningState() == static_cast(DEV_RUNNING_DOWN)), RT_ERROR_DRV_ERR, + "Device %u is unavailable, stream_id=%u.", device_->Id_(), streamId_); const rtError_t error = device_->Driver_()->GetSqTail(devId, tsId, sqId_, sqTail); - ERROR_RETURN_MSG_INNER(error, "Failed to get sq tail, stream_id=%d, task_id=%u, dev_id=%u, ts_id=%u.", - streamId_, taskId, devId, tsId); + ERROR_RETURN_MSG_INNER( + error, "Failed to get sq tail, stream_id=%d, task_id=%u, dev_id=%u, ts_id=%u.", streamId_, taskId, devId, + tsId); // Sq have no task, return OK if (sqTail == 0U) { - RT_LOG(RT_LOG_EVENT, "Model wait finish, device_id=%u, ts_id=%u, stream_id=%d, sqTail=%u", - devId, tsId, streamId_, sqTail); + RT_LOG( + RT_LOG_EVENT, "Model wait finish, device_id=%u, ts_id=%u, stream_id=%d, sqTail=%u", devId, tsId, + streamId_, sqTail); return RT_ERROR_NONE; } @@ -3783,9 +3894,10 @@ rtError_t Stream::ModelWaitForTask(const uint32_t taskId, const bool isNeedWaitS NULL_PTR_RETURN_MSG(preTask, RT_ERROR_TASK_NULL); uint32_t prePos = preTask->pos; if (TASK_ID_GEQ(sqTail, prePos)) { - RT_LOG(RT_LOG_DEBUG, "Model wait finish, device_id=%u, ts_id=%u, stream_id=%d, prePos=%u, sqTail=%u", - devId, tsId, streamId_, prePos, sqTail); - return RT_ERROR_NONE; + RT_LOG( + RT_LOG_DEBUG, "Model wait finish, device_id=%u, ts_id=%u, stream_id=%d, prePos=%u, sqTail=%u", devId, + tsId, streamId_, prePos, sqTail); + return RT_ERROR_NONE; } if (TASK_ID_LT(TASK_ID_ADD(sqTail, RT_SYNC_SLEEP_INTERVAL), prePos)) { @@ -3823,11 +3935,12 @@ uint32_t Stream::StarsGetMaxTryCount() const rtError_t Stream::SubmitRecordTask(int32_t timeout) { TaskInfo submitTask = {}; - TaskInfo *tsk = &submitTask; + TaskInfo* tsk = &submitTask; rtError_t error = ProcRecordTask(tsk); - ERROR_RETURN_MSG_INNER(error, "Failed to submit record task, device_id=%u, stream_id=%d.", device_->Id_(), streamId_); + ERROR_RETURN_MSG_INNER( + error, "Failed to submit record task, device_id=%u, stream_id=%d.", device_->Id_(), streamId_); - EventRecordTaskInfo * const eventRecordTsk = &(tsk->u.eventRecordTaskInfo); + EventRecordTaskInfo* const eventRecordTsk = &(tsk->u.eventRecordTaskInfo); eventRecordTsk->waitCqflag = true; eventRecordTsk->timeout = timeout; tsk->isNeedStreamSync = true; @@ -3837,8 +3950,8 @@ rtError_t Stream::SubmitRecordTask(int32_t timeout) // recycle task here; in the case of stream abort, task is recycled in Stream::ResClear instead; if ((error == RT_ERROR_STREAM_SYNC_TIMEOUT) || (error == RT_ERROR_STREAM_ABORT_SYNC_TASK_FAIL) || (error == RT_ERROR_DEVICE_ABORT_SYNC_TASK_FAIL)) { - RT_LOG(RT_LOG_WARNING, - "fail to submit EventRecordTask, because timeout or stream is abort status, error=%u.", + RT_LOG( + RT_LOG_WARNING, "fail to submit EventRecordTask, because timeout or stream is abort status, error=%u.", error); SetNeedSyncFlag(true); return error; @@ -3853,13 +3966,15 @@ rtError_t Stream::SubmitRecordTask(int32_t timeout) return error; } -rtError_t Stream::StarsWaitForTask(const uint32_t taskId, const bool isNeedWaitSyncCq, - int32_t timeout) +rtError_t Stream::StarsWaitForTask(const uint32_t taskId, const bool isNeedWaitSyncCq, int32_t timeout) { rtError_t errorCode = RT_ERROR_NONE; const uint32_t deviceId = device_->Id_(); - RT_LOG(RT_LOG_DEBUG, "Begin wait for task, device_id=%u, stream_id=%d, task_id=%u, finish_task_id=%u, " - "last_task_id=%u, timeout=%dms.", deviceId, streamId_, taskId, finishTaskId_, lastTaskId_, timeout); + RT_LOG( + RT_LOG_DEBUG, + "Begin wait for task, device_id=%u, stream_id=%d, task_id=%u, finish_task_id=%u, " + "last_task_id=%u, timeout=%dms.", + deviceId, streamId_, taskId, finishTaskId_, lastTaskId_, timeout); if ((!device_->IsSupportFeature(RtOptionalFeatureType::RT_FEATURE_MODEL_STREAM_DOT_SYNC)) && (GetBindFlag())) { return ModelWaitForTask(taskId, isNeedWaitSyncCq); @@ -3883,11 +3998,8 @@ rtError_t Stream::StarsWaitForTask(const uint32_t taskId, const bool isNeedWaitS // to avoid parallelized execution with Stream::SqcqUpdate if (abortStatus_ == RT_ERROR_STREAM_ABORT) { StreamSyncUnLock(); - RT_LOG_INNER_MSG(RT_LOG_ERROR, - "The stream %u is in abort state, sq_id=%u, cq_id=%u.", - streamId_, - sqId_, - cqId_); + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "The stream %u is in abort state, sq_id=%u, cq_id=%u.", streamId_, sqId_, cqId_); return RT_ERROR_STREAM_ABORT; } @@ -3916,18 +4028,23 @@ rtError_t Stream::StarsWaitForTask(const uint32_t taskId, const bool isNeedWaitS this->SetSyncRemainTime(-1); StreamSyncUnLock(); if (errorCode != RT_ERROR_NONE) { - RT_LOG(RT_LOG_ERROR, "Query Task status failed, device_id=%u, stream_id=%d, retCode=%#x", - deviceId, streamId_, errorCode); + RT_LOG( + RT_LOG_ERROR, "Query Task status failed, device_id=%u, stream_id=%d, retCode=%#x", deviceId, streamId_, + errorCode); return errorCode; } // Event occurred. if (IsWaitFinish(currentId, taskId)) { StreamSyncFinishReport(); - RT_LOG(RT_LOG_DEBUG, "Wait finish, device_id=%u, stream_id=%d, task_id=%u, current_id=%u, " - "tryCount=%u", deviceId, streamId_, taskId, currentId, tryCount); + RT_LOG( + RT_LOG_DEBUG, + "Wait finish, device_id=%u, stream_id=%d, task_id=%u, current_id=%u, " + "tryCount=%u", + deviceId, streamId_, taskId, currentId, tryCount); const uint64_t timeCnt1 = isNeedRecordSyncTimeout ? GetTimeInterval(beginTime) : 0ULL; - COND_PROC((isNeedRecordSyncTimeout && (timeCnt1 > ADC_MODEL_EXE_TIMEOUT)), + COND_PROC( + (isNeedRecordSyncTimeout && (timeCnt1 > ADC_MODEL_EXE_TIMEOUT)), RT_LOG(RT_LOG_EVENT, "sync/model exec timeout, timeCnt1=%ums, stream_id=%u", timeCnt1, streamId_)); return RT_ERROR_NONE; } @@ -3935,7 +4052,8 @@ rtError_t Stream::StarsWaitForTask(const uint32_t taskId, const bool isNeedWaitS if (tryCount >= maxTryCount) { if (timeout > 0) { const uint64_t count = GetTimeInterval(beginTime); - COND_RETURN_ERROR_MSG_INNER((count >= static_cast(timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, + COND_RETURN_ERROR_MSG_INNER( + (count >= static_cast(timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, "Stream synchronize timeout, device_id=%u, stream_id=%d, time=%lums, timeout=%dms, tryCount=%u.", deviceId, streamId_, count, timeout, tryCount); timeout = (timeout - static_cast(count)); @@ -3944,7 +4062,8 @@ rtError_t Stream::StarsWaitForTask(const uint32_t taskId, const bool isNeedWaitS } errorCode = CheckContextStatus(false); - COND_RETURN_ERROR(errorCode != RT_ERROR_NONE, errorCode, "context is abort, status=%#x.", static_cast(errorCode)); + COND_RETURN_ERROR( + errorCode != RT_ERROR_NONE, errorCode, "context is abort, status=%#x.", static_cast(errorCode)); if ((currentId != UINT16_MAX) && TASK_ID_LT(TASK_ID_ADD(currentId, RT_SYNC_SLEEP_INTERVAL), taskId)) { (void)mmSleep(1U); @@ -3955,9 +4074,11 @@ rtError_t Stream::StarsWaitForTask(const uint32_t taskId, const bool isNeedWaitS if ((tryCount % perSchedYield) == 0U) { if (timeout > 0) { const uint64_t count = GetTimeInterval(beginTime); - COND_RETURN_INFO((count >= static_cast(timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, + COND_RETURN_INFO( + (count >= static_cast(timeout)), RT_ERROR_STREAM_SYNC_TIMEOUT, "SchedYield stream sync timeout, device_id=%u, stream_id=%d, time=%lums, timeout=%dms, " - "tryCount=%u", deviceId, streamId_, count, timeout, tryCount); + "tryCount=%u", + deviceId, streamId_, count, timeout, tryCount); remainTime = (timeout - static_cast(count)); } (void)sched_yield(); @@ -3966,13 +4087,15 @@ rtError_t Stream::StarsWaitForTask(const uint32_t taskId, const bool isNeedWaitS const uint64_t timeCnt2 = GetTimeInterval(beginTime); errorCode = SubmitRecordTask(timeout); const uint64_t timeCnt3 = GetTimeInterval(beginTime); - COND_PROC((isNeedRecordSyncTimeout && (timeCnt3 > ADC_MODEL_EXE_TIMEOUT)), - RT_LOG(RT_LOG_EVENT, "sync/model exec timeout, timeCnt2=%lums, timeCnt3=%lums, stream_id=%u", - timeCnt2, timeCnt3, streamId_)); + COND_PROC( + (isNeedRecordSyncTimeout && (timeCnt3 > ADC_MODEL_EXE_TIMEOUT)), + RT_LOG( + RT_LOG_EVENT, "sync/model exec timeout, timeCnt2=%lums, timeCnt3=%lums, stream_id=%u", timeCnt2, timeCnt3, + streamId_)); return errorCode; } -rtError_t Stream::GetTaskIdByPos(const uint16_t recycleHead, uint32_t &taskId) +rtError_t Stream::GetTaskIdByPos(const uint16_t recycleHead, uint32_t& taskId) { const uint32_t rtsqDepth = (((flags_ & RT_STREAM_HUGE) != 0U) && (device_->GetDevProperties().maxTaskNumPerHugeStream != 0)) ? @@ -3991,8 +4114,8 @@ rtError_t Stream::GetTaskIdByPos(const uint16_t recycleHead, uint32_t &taskId) return RT_ERROR_NONE; } -rtError_t Stream::AllocLogicCq(const bool isDisableThread, const bool starsFlag, StreamSqCqManage * const stmSqCqManage, - const uint32_t drvFlag) +rtError_t Stream::AllocLogicCq( + const bool isDisableThread, const bool starsFlag, StreamSqCqManage* const stmSqCqManage, const uint32_t drvFlag) { if (!isDisableThread) { return RT_ERROR_NONE; @@ -4005,8 +4128,8 @@ rtError_t Stream::AllocLogicCq(const bool isDisableThread, const bool starsFlag, rtError_t error; if (dvppGrp_ == nullptr) { - error = stmSqCqManage->AllocLogicCq(static_cast(streamId_), needFastcqFlag_, - logicCqId, isFastCq, true, drvFlag); + error = stmSqCqManage->AllocLogicCq( + static_cast(streamId_), needFastcqFlag_, logicCqId, isFastCq, true, drvFlag); ERROR_RETURN_MSG_INNER(error, "Failed to alloc logic cq, stream_id=%d.", streamId_); if (needFastcqFlag_ && (!isFastCq)) { RT_LOG(RT_LOG_DEBUG, "Failed to alloc fast logic cq, stream_id=%d.", streamId_); @@ -4020,10 +4143,10 @@ rtError_t Stream::AllocLogicCq(const bool isDisableThread, const bool starsFlag, if (starsFlag) { SetLogicalCqId(logicCqId); // stars need streamId binding logicCqId - error = device_->Driver_()->StreamBindLogicCq(devId, tsId, static_cast(streamId_), - logicCqId, drvFlag); - ERROR_RETURN_MSG_INNER(error, "Failed to bind streamId and logicCqId, stream_id=%d, logicCq=%u.", - streamId_, logicCqId); + error = + device_->Driver_()->StreamBindLogicCq(devId, tsId, static_cast(streamId_), logicCqId, drvFlag); + ERROR_RETURN_MSG_INNER( + error, "Failed to bind streamId and logicCqId, stream_id=%d, logicCq=%u.", streamId_, logicCqId); } RT_LOG(RT_LOG_DEBUG, "alloc logic cq success, stream_id=%d, logicCq=%u.", streamId_, logicCqId); @@ -4031,7 +4154,7 @@ rtError_t Stream::AllocLogicCq(const bool isDisableThread, const bool starsFlag, } // get taskId by rtsq head that has Finished -rtError_t Stream::GetLastTaskIdFromRtsq(uint32_t &lastTaskId) +rtError_t Stream::GetLastTaskIdFromRtsq(uint32_t& lastTaskId) { if (device_ == nullptr) { RT_LOG(RT_LOG_WARNING, "device is null, stream_id=%d", streamId_); @@ -4042,8 +4165,8 @@ rtError_t Stream::GetLastTaskIdFromRtsq(uint32_t &lastTaskId) const uint32_t tsId = device_->DevGetTsId(); rtError_t error = device_->Driver_()->GetSqHead(device_->Id_(), tsId, sqId, sqHead); - COND_RETURN_ERROR_MSG_INNER(error != RT_ERROR_NONE, error, "Query sq head failed, retCode=%#x", - static_cast(error)); + COND_RETURN_ERROR_MSG_INNER( + error != RT_ERROR_NONE, error, "Query sq head failed, retCode=%#x", static_cast(error)); // get taskId by postion, sqHead is executing Currently, pos has been executed. const rtChipType_t chipType = Runtime::Instance()->GetChipType(); @@ -4062,14 +4185,14 @@ rtError_t Stream::GetLastTaskIdFromRtsq(uint32_t &lastTaskId) return error; } -rtError_t Stream::JudgeTaskFinish(uint16_t taskPos, bool &isFinished) +rtError_t Stream::JudgeTaskFinish(uint16_t taskPos, bool& isFinished) { UNUSED(taskPos); UNUSED(isFinished); return RT_ERROR_NONE; } -rtError_t Stream::JudgeHeadTailPos(rtEventStatus_t * const status, uint16_t eventPos) +rtError_t Stream::JudgeHeadTailPos(rtEventStatus_t* const status, uint16_t eventPos) { COND_RETURN_WARN(device_ == nullptr, RT_ERROR_NONE, "device is null, stream_id=%d", streamId_); @@ -4078,7 +4201,8 @@ rtError_t Stream::JudgeHeadTailPos(rtEventStatus_t * const status, uint16_t even const uint32_t tsId = device_->DevGetTsId(); const uint16_t sqTail = taskPosTail_.Value(); const rtError_t error = device_->Driver_()->GetSqHead(device_->Id_(), tsId, sqId, sqHead); - COND_RETURN_ERROR_MSG_INNER(error != RT_ERROR_NONE, error, "Query sq head failed, retCode=%#x", static_cast(error)); + COND_RETURN_ERROR_MSG_INNER( + error != RT_ERROR_NONE, error, "Query sq head failed, retCode=%#x", static_cast(error)); if (sqHead < sqTail) { if (sqHead > eventPos || eventPos > sqTail) { *status = RT_EVENT_RECORDED; @@ -4094,12 +4218,13 @@ rtError_t Stream::JudgeHeadTailPos(rtEventStatus_t * const status, uint16_t even } else { *status = RT_EVENT_RECORDED; } - RT_LOG(RT_LOG_INFO, "device_id=%u, status=%d, stream_id=%u, head=%u, tail=%u, pos=%u", - device_->Id_(), *status, streamId_, sqHead, sqTail, eventPos); + RT_LOG( + RT_LOG_INFO, "device_id=%u, status=%d, stream_id=%u, head=%u, tail=%u, pos=%u", device_->Id_(), *status, + streamId_, sqHead, sqTail, eventPos); return RT_ERROR_NONE; } -rtError_t Stream::GetLastFinishTaskId(const uint32_t taskId, uint32_t &currId, int32_t timeout) +rtError_t Stream::GetLastFinishTaskId(const uint32_t taskId, uint32_t& currId, int32_t timeout) { rtError_t errorCode = RT_ERROR_NONE; @@ -4107,12 +4232,13 @@ rtError_t Stream::GetLastFinishTaskId(const uint32_t taskId, uint32_t &currId, i errorCode = StarsWaitForTask(taskId, false, timeout); currId = taskId; } else { - TaskInfo *eventRecordTsk = device_->GetTaskFactory()->GetTask(streamId_, static_cast(taskId)); + TaskInfo* eventRecordTsk = device_->GetTaskFactory()->GetTask(streamId_, static_cast(taskId)); if (eventRecordTsk == nullptr) { RT_LOG(RT_LOG_WARNING, "Get null task from stream_id=%d, task_id=%u", streamId_, taskId); errorCode = device_->QueryLatestTaskId(static_cast(streamId_), currId); - COND_RETURN_ERROR(errorCode != RT_ERROR_NONE, errorCode, - "Query null Task status failed, retCode=%#x.", static_cast(errorCode)); + COND_RETURN_ERROR( + errorCode != RT_ERROR_NONE, errorCode, "Query null Task status failed, retCode=%#x.", + static_cast(errorCode)); return errorCode; } const uint64_t eventFlag = eventRecordTsk->u.eventRecordTaskInfo.event->GetEventFlag(); @@ -4122,8 +4248,9 @@ rtError_t Stream::GetLastFinishTaskId(const uint32_t taskId, uint32_t &currId, i } else { errorCode = device_->QueryLatestTaskId(static_cast(streamId_), currId); } - COND_RETURN_ERROR(errorCode != RT_ERROR_NONE, errorCode, - "Query Task status failed, retCode=%#x.", static_cast(errorCode)); + COND_RETURN_ERROR( + errorCode != RT_ERROR_NONE, errorCode, "Query Task status failed, retCode=%#x.", + static_cast(errorCode)); } return errorCode; } @@ -4137,11 +4264,12 @@ void* Stream::GetDvppRRTaskAddr(void) } const std::lock_guard lock(dvppRRTaskAddrLock_); - const rtError_t error = device_->Driver_()->DevMemAlloc(&dvppRRTaskAddr_, DVPP_RR_WRITE_VALUE_LEN, - RT_MEMORY_DEFAULT, device_->Id_()); + const rtError_t error = + device_->Driver_()->DevMemAlloc(&dvppRRTaskAddr_, DVPP_RR_WRITE_VALUE_LEN, RT_MEMORY_DEFAULT, device_->Id_()); if (error != RT_ERROR_NONE) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, "Failed to allocate device memory, stream_id=%d, size=%u, retCode=%#x", - streamId_, DVPP_RR_WRITE_VALUE_LEN, error); + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "Failed to allocate device memory, stream_id=%d, size=%u, retCode=%#x", streamId_, + DVPP_RR_WRITE_VALUE_LEN, error); return nullptr; } @@ -4163,12 +4291,13 @@ rtError_t Stream::SetFailMode(const uint64_t mode) TaskInfo submitTask = {}; rtError_t errorReason; - TaskInfo *tsk = AllocTask(&submitTask, TS_TASK_TYPE_SET_STREAM_MODE, errorReason); + TaskInfo* tsk = AllocTask(&submitTask, TS_TASK_TYPE_SET_STREAM_MODE, errorReason); NULL_PTR_RETURN_MSG(tsk, errorReason); (void)SetStreamModeTaskInit(tsk, mode); errorCode = device_->SubmitTask(tsk); - ERROR_GOTO_MSG_INNER(errorCode, RECYCLE, "Submit set stream failure mode task failed, retCode=%#x.", + ERROR_GOTO_MSG_INNER( + errorCode, RECYCLE, "Submit set stream failure mode task failed, retCode=%#x.", static_cast(errorCode)); SetFailureMode(mode); SetMode(GetMode() | (mode & STREAM_FAILURE_MODE_MASK)); @@ -4201,10 +4330,11 @@ void Stream::EnterFailureAbort() RT_LOG(RT_LOG_ERROR, "stream_id=%d enter failure abort.", Id_()); if (!Runtime::Instance()->GetDisableThread()) { const std::lock_guard eventTaskLock(eventTaskListLock_); - for (auto &evtTsk : eventTaskList) { + for (auto& evtTsk : eventTaskList) { if ((evtTsk != nullptr) && (evtTsk->type == TS_TASK_TYPE_EVENT_RECORD) && (evtTsk->stream == this)) { - RT_LOG(RT_LOG_INFO, "stream_id=%u task_id=%u trigger event_id=%u.", - Id_(), evtTsk->id, evtTsk->u.eventRecordTaskInfo.eventid); + RT_LOG( + RT_LOG_INFO, "stream_id=%u task_id=%u trigger event_id=%u.", Id_(), evtTsk->id, + evtTsk->u.eventRecordTaskInfo.eventid); TaskTriggerEvent(evtTsk); } } @@ -4213,8 +4343,8 @@ void Stream::EnterFailureAbort() } bool Stream::IsSeparateSendAndRecycle() const { - return device_->IsStarsPlatform() && device_->GetIsChipSupportRecycleThread() && - !IsBindDvppGrp() && !IsSoftwareSqEnable() && ((Flags() & (RT_STREAM_AICPU | RT_STREAM_CP_PROCESS_USE)) == 0U); + return device_->IsStarsPlatform() && device_->GetIsChipSupportRecycleThread() && !IsBindDvppGrp() && + !IsSoftwareSqEnable() && ((Flags() & (RT_STREAM_AICPU | RT_STREAM_CP_PROCESS_USE)) == 0U); } void Stream::EraseEventTask(TaskInfo* const tsk) @@ -4229,8 +4359,9 @@ void Stream::EraseEventTask(TaskInfo* const tsk) return; } eventTaskList.erase(tsk); - RT_LOG(RT_LOG_INFO, "stream_id=%d task_id=%u with event_id=%d is erased.", - Id_(), tsk->id, tsk->u.eventRecordTaskInfo.eventid); + RT_LOG( + RT_LOG_INFO, "stream_id=%d task_id=%u with event_id=%d is erased.", Id_(), tsk->id, + tsk->u.eventRecordTaskInfo.eventid); } } void Stream::InsertEventTask(TaskInfo* const tsk) @@ -4244,8 +4375,9 @@ void Stream::InsertEventTask(TaskInfo* const tsk) const std::lock_guard eventTaskLock(eventTaskListLock_); if (tsk->type == TS_TASK_TYPE_EVENT_RECORD) { (void)eventTaskList.insert(tsk); - RT_LOG(RT_LOG_INFO, "stream_id=%u task_id=%u with event_id=%d is inserted.", - Id_(), tsk->id, tsk->u.eventRecordTaskInfo.eventid); + RT_LOG( + RT_LOG_INFO, "stream_id=%u task_id=%u with event_id=%d is inserted.", Id_(), tsk->id, + tsk->u.eventRecordTaskInfo.eventid); } } @@ -4293,7 +4425,7 @@ bool Stream::IsExistCqe(void) const return status; } -void Stream::AddTaskTag(const uint16_t taskId, const std::string &taskTag) +void Stream::AddTaskTag(const uint16_t taskId, const std::string& taskTag) { const std::unique_lock lk(taskIdToTaskTagMapMutex_); taskIdToTaskTagMap_[taskId] = taskTag; @@ -4308,10 +4440,10 @@ void Stream::DelTaskTag(const uint16_t taskId) rtError_t Stream::GetStarsVersion() { NULL_PTR_RETURN(device_, RT_ERROR_DEVICE_NULL); - auto * const factory = device_->GetTaskFactory(); + auto* const factory = device_->GetTaskFactory(); TaskInfo taskSubmit = {}; - TaskInfo *tsk = &taskSubmit; + TaskInfo* tsk = &taskSubmit; Stream* stm = this; tsk->stream = stm; rtError_t error = RT_ERROR_TASK_NEW; @@ -4345,28 +4477,30 @@ const std::string Stream::GetTaskTag(const uint16_t taskId) bool Stream::GetForceRecycleFlag(bool flag) const { - bool forceRecycleFlag = (flag || (GetFailureMode() == ABORT_ON_FAILURE)) || - ((GetStreamStatus() != StreamStatus::NORMAL)); + bool forceRecycleFlag = + (flag || (GetFailureMode() == ABORT_ON_FAILURE)) || ((GetStreamStatus() != StreamStatus::NORMAL)); if ((context_ != nullptr) && (context_->GetFailureError() != RT_ERROR_NONE)) { forceRecycleFlag = true; } return forceRecycleFlag; } -rtError_t Stream::ModelTaskUpdate(const Stream * desStm, uint32_t desTaskId, void *devCopyMem, uint32_t tilingTabLen, - rtMdlTaskUpdateInfo_t *para) +rtError_t Stream::ModelTaskUpdate( + const Stream* desStm, uint32_t desTaskId, void* devCopyMem, uint32_t tilingTabLen, rtMdlTaskUpdateInfo_t* para) { NULL_PTR_RETURN(device_, RT_ERROR_DEVICE_NULL); TaskInfo taskSubmit = {}; rtError_t errorReason = RT_ERROR_NONE; - TaskInfo *tsk = AllocTask(&taskSubmit, TS_TASK_TYPE_MODEL_TASK_UPDATE, errorReason); + TaskInfo* tsk = AllocTask(&taskSubmit, TS_TASK_TYPE_MODEL_TASK_UPDATE, errorReason); NULL_PTR_RETURN_MSG(tsk, errorReason); - auto * const factory = device_->GetTaskFactory(); - rtError_t error = ModelTaskUpdateInit(tsk, static_cast(desStm->Id_()), desTaskId, - static_cast(Id_()), devCopyMem, tilingTabLen, para); - COND_PROC((error == RT_ERROR_DRV_IOCTRL), + auto* const factory = device_->GetTaskFactory(); + rtError_t error = ModelTaskUpdateInit( + tsk, static_cast(desStm->Id_()), desTaskId, static_cast(Id_()), devCopyMem, tilingTabLen, + para); + COND_PROC( + (error == RT_ERROR_DRV_IOCTRL), RT_LOG(RT_LOG_ERROR, "MemTranslate offset may used out, Please reduce IFA update task num.")); ERROR_GOTO(error, ERROR_TASK, "Failed to init model update task.error=%d.", error); @@ -4397,17 +4531,20 @@ void Stream::FreeOnlineProf() const (void)Device_()->DevSetOnlineProfStart(false); if (onProfDeviceAddr_ != nullptr) { error = device_->Driver_()->DevMemFree(onProfDeviceAddr_, device_->Id_()); - COND_LOG(error != RT_ERROR_NONE, "Free online profiling memory deviceMem failed, retCode=%#x", + COND_LOG( + error != RT_ERROR_NONE, "Free online profiling memory deviceMem failed, retCode=%#x", static_cast(error)); } if (onProfHostRtAddr_ != nullptr) { error = device_->Driver_()->HostMemFree(onProfHostRtAddr_); - COND_LOG(error != RT_ERROR_NONE, "Free online profiling memory hostRtMem failed, retCode=%#x", + COND_LOG( + error != RT_ERROR_NONE, "Free online profiling memory hostRtMem failed, retCode=%#x", static_cast(error)); } if (onProfHostTsAddr_ != nullptr) { error = device_->Driver_()->HostMemFree(onProfHostTsAddr_); - COND_LOG(error != RT_ERROR_NONE, "Free online profiling memory hostTsMem failed, retCode=%#x", + COND_LOG( + error != RT_ERROR_NONE, "Free online profiling memory hostTsMem failed, retCode=%#x", static_cast(error)); } } @@ -4426,8 +4563,8 @@ void Stream::ResetStreamConstruct() taskIdFlipNum_.Set(0); recycleFlag_.Set(false); limitFlag_.Set(false); - (void)memset_s(posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0xFFU, - posToTaskIdMapSize_ * sizeof(uint16_t)); + (void)memset_s( + posToTaskIdMap_, posToTaskIdMapSize_ * sizeof(uint16_t), 0xFFU, posToTaskIdMapSize_ * sizeof(uint16_t)); SetRecycleEndTaskId(MAX_UINT16_NUM); SetExecuteEndTaskId(static_cast(MAX_UINT16_NUM)); taskPosHead_.Set(0); @@ -4474,12 +4611,13 @@ rtError_t Stream::ResClear(uint64_t timeout) uint64_t tryCount = 0; constexpr uint64_t perDetectTimes = 1000U; mmTimespec endCnt = {}; - uint64_t endTime; + uint64_t endTime; const mmTimespec startCnt = mmGetTickCount(); - const uint64_t startTime = static_cast(startCnt.tv_sec) * RT_MS_PER_S + - static_cast(startCnt.tv_nsec) / RT_MS_TO_NS; + const uint64_t startTime = + static_cast(startCnt.tv_sec) * RT_MS_PER_S + static_cast(startCnt.tv_nsec) / RT_MS_TO_NS; while (pendingNum_.Value() > 0U) { - COND_RETURN_ERROR_MSG_INNER((device_->GetDevRunningState() == static_cast(DEV_RUNNING_DOWN)), RT_ERROR_DRV_ERR, + COND_RETURN_ERROR_MSG_INNER( + (device_->GetDevRunningState() == static_cast(DEV_RUNNING_DOWN)), RT_ERROR_DRV_ERR, "Device %u is unavailable, clear stream_id=%u.", device_->Id_(), streamId_); if (IsSeparateSendAndRecycle()) { isForceRecycle_ = true; @@ -4496,12 +4634,15 @@ rtError_t Stream::ResClear(uint64_t timeout) StreamSyncUnLock(); } tryCount++; - if(timeout >0 && tryCount % perDetectTimes == 0) { + if (timeout > 0 && tryCount % perDetectTimes == 0) { endCnt = mmGetTickCount(); endTime = static_cast(endCnt.tv_sec) * RT_MS_PER_S + - static_cast(endCnt.tv_nsec) / RT_MS_TO_NS; - COND_RETURN_ERROR_MSG_INNER(((endTime - startTime) > timeout), RT_ERROR_WAIT_TIMEOUT, "Task reclaim timeout, " - "stream_id=%d, sq_id=%u, cq_id=%u, pendingNum=%u.", streamId_, sqId_, cqId_, pendingNum_.Value()); + static_cast(endCnt.tv_nsec) / RT_MS_TO_NS; + COND_RETURN_ERROR_MSG_INNER( + ((endTime - startTime) > timeout), RT_ERROR_WAIT_TIMEOUT, + "Task reclaim timeout, " + "stream_id=%d, sq_id=%u, cq_id=%u, pendingNum=%u.", + streamId_, sqId_, cqId_, pendingNum_.Value()); } } rtError_t error = RT_ERROR_NONE; @@ -4520,7 +4661,8 @@ rtError_t Stream::ResClear(uint64_t timeout) return error; } -void Stream::Destructor() { +void Stream::Destructor() +{ if ((((flags_ & RT_STREAM_FORBIDDEN_DEFAULT) == 0U) && ((flags_ & RT_STREAM_AICPU) == 0U))) { device_->GetStreamSqCqManage()->DelStreamIdToStream(static_cast(streamId_)); } @@ -4548,7 +4690,7 @@ rtError_t Stream::UpdateTask(TaskInfo** updateTask) { *updateTask = nullptr; const std::lock_guard tskGrpLock(GetTaskGrpMutex()); - TaskGroup *updateTaskGroup = GetUpdateTaskGroup(); + TaskGroup* updateTaskGroup = GetUpdateTaskGroup(); if (updateTaskGroup == nullptr) { RT_LOG_INNER_MSG(RT_LOG_ERROR, "The updateTaskGroup is a NULL pointer."); @@ -4557,10 +4699,10 @@ rtError_t Stream::UpdateTask(TaskInfo** updateTask) uint32_t taskIndex = updateTaskGroup->updateTaskIndex; if (taskIndex >= updateTaskGroup->taskIds.size()) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "The number of tasks cannot exceed the size of the task group, current task index=%u, task group size=%lu.", - taskIndex, - updateTaskGroup->taskIds.size()); + taskIndex, updateTaskGroup->taskIds.size()); return RT_ERROR_STREAM_TASKGRP_UPDATE; } @@ -4570,21 +4712,22 @@ rtError_t Stream::UpdateTask(TaskInfo** updateTask) TaskInfo* taskInfo = GetStreamTaskInfo(device_, streamId, taskId); if (unlikely(taskInfo == nullptr)) { - RT_LOG_INNER_MSG(RT_LOG_ERROR, - "stream_id or task_id is invalid, stream_id=%hu, task_id=%hu.", streamId, taskId); + RT_LOG_INNER_MSG( + RT_LOG_ERROR, "stream_id or task_id is invalid, stream_id=%hu, task_id=%hu.", streamId, taskId); return RT_ERROR_STREAM_TASKGRP_UPDATE; } taskInfo->isUpdateSinkSqe = 1U; *updateTask = taskInfo; UpdateTaskIndex(taskIndex + 1U); - RT_LOG(RT_LOG_DEBUG, "stream_id=%hu, task_id=%hu, current task index=%u, task group size=%u", - streamId, taskId, taskIndex, updateTaskGroup->taskIds.size()); + RT_LOG( + RT_LOG_DEBUG, "stream_id=%hu, task_id=%hu, current task index=%u, task group size=%u", streamId, taskId, + taskIndex, updateTaskGroup->taskIds.size()); return RT_ERROR_NONE; } -TaskInfo* Stream::AllocTask(TaskInfo* pTask, tsTaskType_t taskType, rtError_t& errorReason, - uint32_t sqeNum, UpdateTaskFlag flag) +TaskInfo* Stream::AllocTask( + TaskInfo* pTask, tsTaskType_t taskType, rtError_t& errorReason, uint32_t sqeNum, UpdateTaskFlag flag) { errorReason = RT_ERROR_TASK_NEW; /* update task group scene */ @@ -4628,8 +4771,9 @@ rtError_t Stream::TaskReclaim(void) StreamSyncLock(); error = device_->TaskReclaim(static_cast(streamId_), false, currId); StreamSyncUnLock(); - COND_RETURN_ERROR_MSG_INNER(error != RT_ERROR_NONE, error, - "Failed to reclaim the task, stream_id=%d, device_id=%u, retCode=%#x.", Id_(), device_->Id_(), error); + COND_RETURN_ERROR_MSG_INNER( + error != RT_ERROR_NONE, error, "Failed to reclaim the task, stream_id=%d, device_id=%u, retCode=%#x.", Id_(), + device_->Id_(), error); return error; } @@ -4644,15 +4788,15 @@ bool Stream::IsStreamFull(const uint32_t head, const uint32_t tail, const uint32 return false; } -void Stream::GetTaskEventIdOrNotifyId(TaskInfo *taskInfo, int32_t &eventId, uint32_t ¬ifyId, uint64_t &devAddr) const +void Stream::GetTaskEventIdOrNotifyId(TaskInfo* taskInfo, int32_t& eventId, uint32_t& notifyId, uint64_t& devAddr) const { - EventRecordTaskInfo *eventRecordTask = nullptr; - EventWaitTaskInfo *eventWaitTask = nullptr; - EventResetTaskInfo *eventResetTask = nullptr; + EventRecordTaskInfo* eventRecordTask = nullptr; + EventWaitTaskInfo* eventWaitTask = nullptr; + EventResetTaskInfo* eventResetTask = nullptr; NotifyWaitTaskInfo* notifyWaitTask = nullptr; - NotifyRecordTaskInfo *notifyRecord = nullptr; - MemWriteValueTaskInfo *memWriteValueTask = nullptr; - MemWaitValueTaskInfo *memWaitValueTask = nullptr; + NotifyRecordTaskInfo* notifyRecord = nullptr; + MemWriteValueTaskInfo* memWriteValueTask = nullptr; + MemWaitValueTaskInfo* memWaitValueTask = nullptr; switch (taskInfo->type) { case TS_TASK_TYPE_EVENT_RECORD: @@ -4687,7 +4831,7 @@ void Stream::GetTaskEventIdOrNotifyId(TaskInfo *taskInfo, int32_t &eventId, uint break; default: - break; + break; } } @@ -4696,19 +4840,23 @@ rtError_t Stream::AllocSoftwareSqAddr(uint32_t additionalSqeNum) rtError_t ret = RT_ERROR_NONE; if (GetSqBaseAddr() == 0ULL) { const uint32_t deviceId = Context_()->Device_()->Id_(); - SqAddrMemoryOrder *sqAddrMemoryManage = Context_()->Device_()->GetSqAddrMemoryManage(); - COND_RETURN_ERROR((sqAddrMemoryManage == nullptr), RT_ERROR_INVALID_VALUE, - "sqAddrMemoryManage is null, device_id=%u.", deviceId); + SqAddrMemoryOrder* sqAddrMemoryManage = Context_()->Device_()->GetSqAddrMemoryManage(); + COND_RETURN_ERROR( + (sqAddrMemoryManage == nullptr), RT_ERROR_INVALID_VALUE, "sqAddrMemoryManage is null, device_id=%u.", + deviceId); - uint64_t *sqBaseAddr = nullptr; + uint64_t* sqBaseAddr = nullptr; const uint32_t allocMemSize = (GetDelayRecycleTaskSqeNum() + additionalSqeNum) * sizeof(rtStarsSqe_t); const uint32_t memOrderType = sqAddrMemoryManage->GetMemOrderTypeByMemSize(allocMemSize); const uint32_t memOrderSize = sqAddrMemoryManage->GetMemOrderSizeByMemOrderType(memOrderType); uint32_t sqDepthAfterUpdate = memOrderSize / sizeof(rtStarsSqe_t); ret = Context_()->Device_()->GetSqAddrMemoryManage()->AllocSqAddr(memOrderType, &sqBaseAddr); - COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, "AllocSqAddr failed. device_id=%u, stream_id=%d, " - "retCode=%#x.", deviceId, Id_(), ret); + COND_RETURN_ERROR( + (ret != RT_ERROR_NONE), ret, + "AllocSqAddr failed. device_id=%u, stream_id=%d, " + "retCode=%#x.", + deviceId, Id_(), ret); SetSqBaseAddr(RtPtrToValue(sqBaseAddr)); SetSqMemOrderType(memOrderType); @@ -4725,9 +4873,9 @@ rtError_t Stream::AllocAutoSplitSqAddr() { rtError_t ret = RT_ERROR_NONE; const uint32_t deviceId = Context_()->Device_()->Id_(); - SqAddrMemoryOrder *sqAddrMemoryManage = Context_()->Device_()->GetSqAddrMemoryManage(); - COND_RETURN_ERROR((sqAddrMemoryManage == nullptr), RT_ERROR_INVALID_VALUE, - "sqAddrMemoryManage is null, device_id=%u.", deviceId); + SqAddrMemoryOrder* sqAddrMemoryManage = Context_()->Device_()->GetSqAddrMemoryManage(); + COND_RETURN_ERROR( + (sqAddrMemoryManage == nullptr), RT_ERROR_INVALID_VALUE, "sqAddrMemoryManage is null, device_id=%u.", deviceId); uint32_t sqeNum = GetDelayRecycleTaskSqeNum() + Device_()->GetDevProperties().expandStreamAdditionalSqeNum; // 按1k粒度向上取整 @@ -4736,11 +4884,14 @@ rtError_t Stream::AllocAutoSplitSqAddr() if (GetSqBaseAddr() == 0ULL) { const uint32_t allocMemSize = sqDepth * sizeof(rtStarsSqe_t); const uint32_t memOrderType = sqAddrMemoryManage->GetMemOrderTypeByMemSize(allocMemSize); - uint64_t *sqBaseAddr = nullptr; + uint64_t* sqBaseAddr = nullptr; ret = Context_()->Device_()->GetSqAddrMemoryManage()->AllocSqAddr(memOrderType, &sqBaseAddr); - COND_RETURN_ERROR((ret != RT_ERROR_NONE), ret, "AllocSqAddr failed. device_id=%u, stream_id=%d, " - "retCode=%#x.", deviceId, Id_(), ret); - + COND_RETURN_ERROR( + (ret != RT_ERROR_NONE), ret, + "AllocSqAddr failed. device_id=%u, stream_id=%d, " + "retCode=%#x.", + deviceId, Id_(), ret); + SetSqMemOrderType(memOrderType); SetSqBaseAddr(RtPtrToValue(sqBaseAddr)); } @@ -4760,7 +4911,7 @@ void Stream::DebugDotPrintForModelStm() std::vector::iterator it; for (it = delayRecycleTaskid_.begin(); it != delayRecycleTaskid_.end(); ++it) { const uint16_t taskId = *it; - TaskInfo *task = device_->GetTaskFactory()->GetTask(Id_(), taskId); + TaskInfo* task = device_->GetTaskFactory()->GetTask(Id_(), taskId); if (task == nullptr) { continue; } @@ -4771,20 +4922,22 @@ void Stream::DebugDotPrintForModelStm() GetTaskEventIdOrNotifyId(task, eventId, notifyId, devAddr); if (eventId != INVALID_EVENT_ID) { - RT_LOG(RT_LOG_EVENT, "device_id=%u, stream_id=%d, task_id=%hu, task_type=%s, event_id=%d.", - device_->Id_(), Id_(), taskId, task->typeName, eventId); + RT_LOG( + RT_LOG_EVENT, "device_id=%u, stream_id=%d, task_id=%hu, task_type=%s, event_id=%d.", device_->Id_(), + Id_(), taskId, task->typeName, eventId); continue; } if (notifyId != MAX_UINT32_NUM) { - RT_LOG(RT_LOG_EVENT, "device_id=%u, stream_id=%d, task_id=%hu, task_type=%s, notify_id=%u.", - device_->Id_(), Id_(), taskId, task->typeName, notifyId); + RT_LOG( + RT_LOG_EVENT, "device_id=%u, stream_id=%d, task_id=%hu, task_type=%s, notify_id=%u.", device_->Id_(), + Id_(), taskId, task->typeName, notifyId); continue; } if ((task->type == TS_TASK_TYPE_KERNEL_AICORE) || (task->type == TS_TASK_TYPE_KERNEL_AIVEC)) { std::string mixTypeName = "NO_MIX"; - const auto &aicTaskInfo = task->u.aicTaskInfo; + const auto& aicTaskInfo = task->u.aicTaskInfo; const uint8_t mixType = (aicTaskInfo.kernel != nullptr) ? aicTaskInfo.kernel->GetMixType() : 0U; if (mixType == MIX_AIC || mixType == MIX_AIC_AIV_MAIN_AIC) { (void)mixTypeName.assign("MIX_AIC"); @@ -4794,17 +4947,19 @@ void Stream::DebugDotPrintForModelStm() ; } - RT_LOG(RT_LOG_EVENT, "device_id=%u, stream_id=%d, task_id=%hu, task_type=%s, mix_type=%s.", - device_->Id_(), Id_(), taskId, task->typeName, mixTypeName.c_str()); - continue; + RT_LOG( + RT_LOG_EVENT, "device_id=%u, stream_id=%d, task_id=%hu, task_type=%s, mix_type=%s.", device_->Id_(), + Id_(), taskId, task->typeName, mixTypeName.c_str()); + continue; } - RT_LOG(RT_LOG_EVENT, "device_id=%u, stream_id=%d, task_id=%hu, task_type=%s.", - device_->Id_(), Id_(), taskId, task->typeName); + RT_LOG( + RT_LOG_EVENT, "device_id=%u, stream_id=%d, task_id=%hu, task_type=%s.", device_->Id_(), Id_(), taskId, + task->typeName); } } -std::string Stream::TraceEventToJson(const TraceEvent &record) const +std::string Stream::TraceEventToJson(const TraceEvent& record) const { std::ostringstream oss; oss << "{"; @@ -4843,17 +4998,17 @@ std::string Stream::TraceEventToJson(const TraceEvent &record) const return oss.str(); } -std::string Stream::GetTaskTypeForMixKernel(const uint8_t mixType, const std::string &originTaskType) const +std::string Stream::GetTaskTypeForMixKernel(const uint8_t mixType, const std::string& originTaskType) const { switch (mixType) { case MIX_AIC: case MIX_AIC_AIV_MAIN_AIC: return "KERNEL_MIX_AIC"; - + case MIX_AIV: case MIX_AIC_AIV_MAIN_AIV: return "KERNEL_MIX_AIV"; - + default: return originTaskType; } @@ -4874,26 +5029,28 @@ void Stream::FillTaskExtendInfo(const TaskInfo* task, TraceEvent& record) const } } -void Stream::SetTraceKernelArgs(const AicTaskInfo *const aicTaskInfo, const uint16_t taskId, TraceArgs &args) const +void Stream::SetTraceKernelArgs(const AicTaskInfo* const aicTaskInfo, const uint16_t taskId, TraceArgs& args) const { - RT_LOG(RT_LOG_DEBUG, "Start to set trace kernel args, device_id=%u, stream_id=%d, taskId=%u.", - device_->Id_(), Id_(), taskId); - const void *const deviceAddr = aicTaskInfo->comm.args; + RT_LOG( + RT_LOG_DEBUG, "Start to set trace kernel args, device_id=%u, stream_id=%d, taskId=%u.", device_->Id_(), Id_(), + taskId); + const void* const deviceAddr = aicTaskInfo->comm.args; const uint32_t argsSize = aicTaskInfo->comm.argsSize; - COND_RETURN_VOID(((deviceAddr == nullptr) || (argsSize == 0U)), - "Can't find kernel args! streamId=%d, taskId=%u", Id_(), taskId); + COND_RETURN_VOID( + ((deviceAddr == nullptr) || (argsSize == 0U)), "Can't find kernel args! streamId=%d, taskId=%u", Id_(), taskId); std::vector hostData(argsSize + 1U, 0U); - const rtError_t error = device_->Driver_()->MemCopySync(&hostData[0U], static_cast(argsSize + 1U), - deviceAddr, static_cast(argsSize), RT_MEMCPY_DEVICE_TO_HOST); + const rtError_t error = device_->Driver_()->MemCopySync( + &hostData[0U], static_cast(argsSize + 1U), deviceAddr, static_cast(argsSize), + RT_MEMCPY_DEVICE_TO_HOST); COND_RETURN_VOID((error != RT_ERROR_NONE), "Call d2h memcpy failed! ret=%d", error); const uint32_t totalLen = argsSize / static_cast(sizeof(uint64_t)); std::stringstream ss; - for (uint32_t i = 0U; i < totalLen ; ++i) { - CheckAndPrintPlaceHolder(aicTaskInfo->launchParam, i * static_cast(sizeof(uint64_t)), ss); + for (uint32_t i = 0U; i < totalLen; ++i) { + CheckAndPrintPlaceHolder(aicTaskInfo->launchParam, i * static_cast(sizeof(uint64_t)), ss); // 每个u64数值按16进制，16位打印完整，用0补齐 - ss << "0x" << std::hex << std::setw(16) << std::setfill('0') << *(RtPtrToPtr(&hostData[0U]) + i); + ss << "0x" << std::hex << std::setw(16) << std::setfill('0') << *(RtPtrToPtr(&hostData[0U]) + i); if (i + 1 < totalLen) { ss << " "; } @@ -4902,14 +5059,14 @@ void Stream::SetTraceKernelArgs(const AicTaskInfo *const aicTaskInfo, const uint args.kernelArgs = ss.str(); } -void Stream::ConstructTraceEventFromTask(TaskInfo *const task, const uint32_t flags, TraceEvent &record) const +void Stream::ConstructTraceEventFromTask(TaskInfo* const task, const uint32_t flags, TraceEvent& record) const { std::string taskName; std::string taskType = (task->typeName != nullptr) ? task->typeName : "Unknown"; if ((task->type == TS_TASK_TYPE_KERNEL_AICORE) || (task->type == TS_TASK_TYPE_KERNEL_AIVEC)) { - AicTaskInfo *aicTaskInfo = &(task->u.aicTaskInfo); + AicTaskInfo* aicTaskInfo = &(task->u.aicTaskInfo); record.args.numBlocks = static_cast(aicTaskInfo->comm.dim); - const Kernel *kernel = aicTaskInfo->kernel; + const Kernel* kernel = aicTaskInfo->kernel; record.args.taskRation = kernel->GetTaskRation(); record.args.schemMode = aicTaskInfo->schemMode; taskType = GetTaskTypeForMixKernel(kernel->GetMixType(), taskType); @@ -4918,13 +5075,13 @@ void Stream::ConstructTraceEventFromTask(TaskInfo *const task, const uint32_t fl SetTraceKernelArgs(aicTaskInfo, task->id, record.args); } } else if (task->type == TS_TASK_TYPE_KERNEL_AICPU) { - AicpuTaskInfo *aicpuTaskInfo = &(task->u.aicpuTaskInfo); + AicpuTaskInfo* aicpuTaskInfo = &(task->u.aicpuTaskInfo); record.args.numBlocks = static_cast(aicpuTaskInfo->comm.dim); - const Kernel *kernel = aicpuTaskInfo->kernel; + const Kernel* kernel = aicpuTaskInfo->kernel; std::string kernelName = (kernel != nullptr) ? kernel->GetCpuOpType() : "AICPU_KERNEL"; taskName = (!kernelName.empty()) ? kernelName : "AICPU_KERNEL"; - } else if (task->type == TS_TASK_TYPE_STREAM_ACTIVE) { - StreamActiveTaskInfo *streamActiveTaskInfo = &(task->u.streamactiveTask); + } else if (task->type == TS_TASK_TYPE_STREAM_ACTIVE) { + StreamActiveTaskInfo* streamActiveTaskInfo = &(task->u.streamactiveTask); record.args.activeStreamId = static_cast(streamActiveTaskInfo->activeStreamId); taskName = task->typeName; } else { @@ -4947,8 +5104,8 @@ void Stream::ConstructTraceEventFromTask(TaskInfo *const task, const uint32_t fl return; } -void Stream::DebugJsonPrintForModelStm(std::ofstream& outputFile, const uint32_t modelId, const bool isLastStm, - const uint32_t flags) +void Stream::DebugJsonPrintForModelStm( + std::ofstream& outputFile, const uint32_t modelId, const bool isLastStm, const uint32_t flags) { if (!GetBindFlag()) { RT_LOG(RT_LOG_DEBUG, "non-model stream, device_id=%u, stream_id=%d.", device_->Id_(), Id_()); @@ -4960,7 +5117,7 @@ void Stream::DebugJsonPrintForModelStm(std::ofstream& outputFile, const uint32_t for (auto it = delayRecycleTaskid_.begin(); it != delayRecycleTaskid_.end(); ++it) { TraceEvent record = {}; const uint16_t taskId = *it; - TaskInfo *task = device_->GetTaskFactory()->GetTask(Id_(), taskId); + TaskInfo* task = device_->GetTaskFactory()->GetTask(Id_(), taskId); if (task == nullptr) { continue; } @@ -4991,7 +5148,7 @@ void Stream::DebugJsonPrintForModelStm(std::ofstream& outputFile, const uint32_t (void)recordArray.emplace_back(record); } - //translate record array to json string; + // translate record array to json string; std::ostringstream json_array; for (size_t i = 0; i < recordArray.size(); ++i) { json_array << TraceEventToJson(recordArray[i]); @@ -5012,18 +5169,14 @@ rtError_t Stream::UpdateTaskGroupStatus(const StreamTaskGroupStatus status) if (status >= StreamTaskGroupStatus::BUTT) { return RT_ERROR_STREAM_TASKGRP_STATUS; } - if ((status != StreamTaskGroupStatus::NONE) && - (taskGroupStatus_ != StreamTaskGroupStatus::NONE)) { + if ((status != StreamTaskGroupStatus::NONE) && (taskGroupStatus_ != StreamTaskGroupStatus::NONE)) { return RT_ERROR_STREAM_TASKGRP_STATUS; } taskGroupStatus_ = status; return RT_ERROR_NONE; } -bool Stream::IsTaskGrouping(void) const -{ - return (taskGroupStatus_ == StreamTaskGroupStatus::SAMPLE); -} +bool Stream::IsTaskGrouping(void) const { return (taskGroupStatus_ == StreamTaskGroupStatus::SAMPLE); } bool Stream::IsTaskGroupBreak() const { @@ -5033,7 +5186,7 @@ bool Stream::IsTaskGroupBreak() const if (captureStream_->GetCurrentTaskGroup() != nullptr) { return false; } - CaptureModel * const mdl = dynamic_cast(captureStream_->Model_()); + CaptureModel* const mdl = dynamic_cast(captureStream_->Model_()); if (mdl == nullptr) { RT_LOG(RT_LOG_ERROR, "capture model is NULL, stream_id=%d.", Id_()); return true; @@ -5044,11 +5197,11 @@ bool Stream::IsTaskGroupBreak() const void Stream::SetTaskGroupErrCode(const rtError_t errorCode) const { - CaptureModel *mdl = nullptr; + CaptureModel* mdl = nullptr; if (captureStream_ == nullptr) { - mdl = dynamic_cast(Model_()); + mdl = dynamic_cast(Model_()); } else { - mdl = dynamic_cast(captureStream_->Model_()); + mdl = dynamic_cast(captureStream_->Model_()); } if (mdl == nullptr) { RT_LOG(RT_LOG_ERROR, "capture model is NULL, stream_id=%d.", Id_()); @@ -5058,7 +5211,7 @@ void Stream::SetTaskGroupErrCode(const rtError_t errorCode) const mdl->SetTaskGroupErrCode(errorCode); } -rtError_t Stream::PackingTaskGroup(const TaskInfo * const task, const uint16_t streamId) +rtError_t Stream::PackingTaskGroup(const TaskInfo* const task, const uint16_t streamId) { NULL_PTR_RETURN_NOLOG(taskGroup_, RT_ERROR_NONE); if (task->type == TS_TASK_TYPE_STREAM_ACTIVE) { @@ -5138,8 +5291,8 @@ rtError_t Stream::StreamTaskClean(void) devId, tsId, streamId_, sqId_); COND_RETURN_ERROR_MSG_INNER( (enable != false), RT_ERROR_STREAM_INVALID, - "During task cleaning, the SQ must be disabled, drv devId=%u, tsId=%u, stream_id=%d, sq_id=%u.", devId, tsId, streamId_, - sqId_); + "During task cleaning, the SQ must be disabled, drv devId=%u, tsId=%u, stream_id=%d, sq_id=%u.", devId, tsId, + streamId_, sqId_); RecycleModelDelayRecycleTask(); // set head and tail to 0 error = device_->Driver_()->SetSqTail(devId, tsId, sqId_, 0U); @@ -5157,20 +5310,25 @@ rtError_t Stream::ReBuildStreamId() streamSwitchInfo_[0].stream_id = UINT32_MAX; streamSwitchInfo_[0].sq_id = GetSqId(); streamSwitchInfo_[0].sq_depth = GetSqDepth(); - streamSwitchInfo_[0].stream_mem = RtValueToPtr(GetSqBaseAddr()); + streamSwitchInfo_[0].stream_mem = RtValueToPtr(GetSqBaseAddr()); /* stream unbind sq */ error = device_->Driver_()->SqSwitchStreamBatch(device_->Id_(), streamSwitchInfo_, 1U); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, "stream unbind sq failed, stream_id=%u, sq_id=%u, retCode=%#x.", Id_(), GetSqId(), static_cast(error)); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, "stream unbind sq failed, stream_id=%u, sq_id=%u, retCode=%#x.", Id_(), + GetSqId(), static_cast(error)); } error = ReBuildDriverStreamResource(); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, "free stream id and realloc stream id failed, stream_id=%u, retCode=%#x.", Id_(), static_cast(error)); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, "free stream id and realloc stream id failed, stream_id=%u, retCode=%#x.", + Id_(), static_cast(error)); if (GetSqBaseAddr() != 0ULL) { - SqAddrMemoryOrder *sqAddrMemoryManage = device_->GetSqAddrMemoryManage(); + SqAddrMemoryOrder* sqAddrMemoryManage = device_->GetSqAddrMemoryManage(); if (sqAddrMemoryManage != nullptr) { - error = sqAddrMemoryManage->FreeSqAddr(RtValueToPtr(GetSqBaseAddr()), GetSqMemOrderType()); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, - "Free sq addr failed, stream_id=%d, retCode=%#x.", Id_(), static_cast(error)); + error = sqAddrMemoryManage->FreeSqAddr(RtValueToPtr(GetSqBaseAddr()), GetSqMemOrderType()); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, "Free sq addr failed, stream_id=%d, retCode=%#x.", Id_(), + static_cast(error)); } } SetSqBaseAddr(0ULL); @@ -5179,11 +5337,11 @@ rtError_t Stream::ReBuildStreamId() } rtError_t Stream::UpdateSnapShotSqe() -{ +{ const size_t size = delayRecycleTaskid_.size(); for (size_t i = 0U; i < size; i++) { const uint16_t taskId = delayRecycleTaskid_[i]; - TaskInfo *task = device_->GetTaskFactory()->GetTask(Id_(), taskId); + TaskInfo* task = device_->GetTaskFactory()->GetTask(Id_(), taskId); NULL_PTR_RETURN_MSG(task, RT_ERROR_INVALID_VALUE); if (IsNeedUpdateTask(task)) { const rtError_t error = SubmitMemCpyAsyncTask(task); @@ -5191,44 +5349,45 @@ rtError_t Stream::UpdateSnapShotSqe() } } - Stream * const stm = context_->GetCtrlSQStream(); + Stream* const stm = context_->GetCtrlSQStream(); constexpr uint32_t waitTimeout = 1000u * 60u * 10u; // 超时等待十分钟 const rtError_t error = stm->Synchronize(false, waitTimeout); ERROR_RETURN(error, "Synchronize failed, streamId=%u, retCode=%#x.", Id_(), error); return RT_ERROR_NONE; } -bool Stream::IsNeedUpdateTask(const TaskInfo * const updateTask) const +bool Stream::IsNeedUpdateTask(const TaskInfo* const updateTask) const { - const std::vector updateTasks = - {TS_TASK_TYPE_STREAM_SWITCH, TS_TASK_TYPE_MODEL_TASK_UPDATE}; - + const std::vector updateTasks = {TS_TASK_TYPE_STREAM_SWITCH, TS_TASK_TYPE_MODEL_TASK_UPDATE}; + return std::find(updateTasks.begin(), updateTasks.end(), updateTask->type) != updateTasks.end(); } -rtError_t Stream::SubmitMemCpyAsyncTask(TaskInfo * const updateTask) +rtError_t Stream::SubmitMemCpyAsyncTask(TaskInfo* const updateTask) { - void *sqeDeviceAddr = nullptr; + void* sqeDeviceAddr = nullptr; rtError_t error = RT_ERROR_NONE; error = device_->Driver_()->DevMemAlloc( &sqeDeviceAddr, static_cast(sizeof(rtStarsSqe_t)), RT_MEMORY_HBM, device_->Id_()); - COND_RETURN_ERROR_MSG_INNER((error != RT_ERROR_NONE) || (sqeDeviceAddr == nullptr), error, - "Failed to allocate device memory, retCode=%#x.", error); + COND_RETURN_ERROR_MSG_INNER( + (error != RT_ERROR_NONE) || (sqeDeviceAddr == nullptr), error, "Failed to allocate device memory, retCode=%#x.", + error); updateTask->stream->RecordDevMemAddr(sqeDeviceAddr); error = UpdateTaskH2DSubmit(updateTask, context_->GetCtrlSQStream(), sqeDeviceAddr); COND_RETURN_ERROR(error != RT_ERROR_NONE, RT_ERROR_NONE, "h2d task submit failed, ret=%d", error); - + error = UpdateTaskD2HSubmit(updateTask, sqeDeviceAddr, context_->GetCtrlSQStream()); COND_RETURN_ERROR(error != RT_ERROR_NONE, RT_ERROR_NONE, "d2h task submit failed, ret=%d", error); return RT_ERROR_NONE; } -rtError_t Stream::StreamGetTasks(void **tasks, uint32_t *numTasks) +rtError_t Stream::StreamGetTasks(void** tasks, uint32_t* numTasks) { - RT_LOG(RT_LOG_INFO, "start to get all tasks in streams, streamId=%d, deviceId=%u, input numTasks=%u.", - streamId_, device_->Id_(), *numTasks); + RT_LOG( + RT_LOG_INFO, "start to get all tasks in streams, streamId=%d, deviceId=%u, input numTasks=%u.", streamId_, + device_->Id_(), *numTasks); std::vector taskIdList; { const std::lock_guard stmLock(streamMutex_); @@ -5237,91 +5396,101 @@ rtError_t Stream::StreamGetTasks(void **tasks, uint32_t *numTasks) const uint32_t taskNum = static_cast(taskIdList.size()); if (tasks == nullptr) { *numTasks = taskNum; - RT_LOG(RT_LOG_INFO, "tasks is nullptr, the number of all tasks in the stream is %u, deviceId=%u, streamId=%d.", + RT_LOG( + RT_LOG_INFO, "tasks is nullptr, the number of all tasks in the stream is %u, deviceId=%u, streamId=%d.", *numTasks, device_->Id_(), streamId_); return RT_ERROR_NONE; } const uint32_t retTaskNum = std::min(*numTasks, taskNum); - TaskFactory *taskFactory = device_->GetTaskFactory(); + TaskFactory* taskFactory = device_->GetTaskFactory(); for (uint32_t i = 0U; i < retTaskNum; i++) { const uint16_t taskId = taskIdList[i]; - TaskInfo *task = taskFactory->GetTask(streamId_, taskId); + TaskInfo* task = taskFactory->GetTask(streamId_, taskId); if (task == nullptr) { RT_LOG(RT_LOG_ERROR, "task is nullptr, deviceId=%u, streamId=%d.", device_->Id_(), streamId_); return RT_ERROR_INVALID_VALUE; } - tasks[i] = reinterpret_cast(task); + tasks[i] = reinterpret_cast(task); } // 如果numTasks大于实际task数量，剩余空间填充null for (uint32_t i = retTaskNum; i < *numTasks; i++) { tasks[i] = nullptr; } *numTasks = retTaskNum; - COND_RETURN_AND_MSG_OUTER(*numTasks < taskNum, RT_ERROR_INSUFFICIENT_INPUT_ARRAY, ErrorCode::EE1011, "Obtaining all tasks in a stream", + COND_RETURN_AND_MSG_OUTER( + *numTasks < taskNum, RT_ERROR_INSUFFICIENT_INPUT_ARRAY, ErrorCode::EE1011, "Obtaining all tasks in a stream", *numTasks, "numTasks", "The array space is insufficient. The array size is less than the total number of tasks in model streams " + - std::to_string(taskNum)); - RT_LOG(RT_LOG_INFO, "end to get all tasks in streams, streamId=%d, deviceId=%u, output numTasks=%u, streamNumTasks=%u.", - streamId_, device_->Id_(), *numTasks, taskNum); + std::to_string(taskNum)); + RT_LOG( + RT_LOG_INFO, + "end to get all tasks in streams, streamId=%d, deviceId=%u, output numTasks=%u, streamNumTasks=%u.", streamId_, + device_->Id_(), *numTasks, taskNum); return RT_ERROR_NONE; } rtError_t Stream::RestoreForSoftwareSq() { RT_LOG(RT_LOG_INFO, "Begin restore capture stream, StreamId=%u.", Id_()); - const Device *dev = Device_(); - Driver *drv = dev->Driver_(); + const Device* dev = Device_(); + Driver* drv = dev->Driver_(); const int32_t deviceId = dev->Id_(); const uint32_t tsId = dev->DevGetTsId(); const uint32_t drvFlag = TSDRV_FLAG_SPECIFIED_CQ_ID; // streamID 重申请 - rtError_t error = drv->ReAllocResourceId(deviceId, tsId, priority_, - static_cast(streamId_), DRV_STREAM_ID); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, "Realloc stream id from driver failed, streamId=%d, deviceId=%u, ret=%d.", + rtError_t error = + drv->ReAllocResourceId(deviceId, tsId, priority_, static_cast(streamId_), DRV_STREAM_ID); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, "Realloc stream id from driver failed, streamId=%d, deviceId=%u, ret=%d.", streamId_, deviceId, error); // logicCqID 重申请 error = drv->LogicCqAllocateV2(deviceId, tsId, streamId_, logicalCqId_, IsBindDvppGrp(), drvFlag); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, - "Alloc logicCq from driver failed, streamId=%u, logicCqId=%u, retCode=%d.", streamId_, logicalCqId_, error); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, "Alloc logicCq from driver failed, streamId=%u, logicCqId=%u, retCode=%d.", + streamId_, logicalCqId_, error); error = drv->StreamBindLogicCq(deviceId, tsId, streamId_, logicalCqId_); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, - "Bind logicCq to stream failed, streamId=%d, deviceId=%u, logicCqId=%u, ret=%d.", - streamId_, deviceId, logicalCqId_, error); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, + "Bind logicCq to stream failed, streamId=%d, deviceId=%u, logicCqId=%u, ret=%d.", streamId_, deviceId, + logicalCqId_, error); // SqId_恢复默认值、cqId_恢复默认值、sqRegVirtualAddr恢复默认值 ResetSqCq(); // sqIdMemAddr内存重置 - error = drv->MemSetSync(RtValueToPtr(sqIdMemAddr_), sizeof(uint64_t), 0U, sizeof(uint64_t)); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, - "Set sq id to invalid value failed, streamId=%d, deviceId=%u, ret=%d.", streamId_, deviceId, error); + error = drv->MemSetSync(RtValueToPtr(sqIdMemAddr_), sizeof(uint64_t), 0U, sizeof(uint64_t)); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, "Set sq id to invalid value failed, streamId=%d, deviceId=%u, ret=%d.", + streamId_, deviceId, error); // sqDepth_恢复默认值 SetSqDepth(STREAM_SQ_MAX_DEPTH); // sqAddr还回池子，并恢复为默认值 if (sqAddr_ != 0U) { - SqAddrMemoryOrder *sqAddrMemoryManage = dev->GetSqAddrMemoryManage(); + SqAddrMemoryOrder* sqAddrMemoryManage = dev->GetSqAddrMemoryManage(); if (sqAddrMemoryManage != nullptr) { - error = sqAddrMemoryManage->FreeSqAddr(RtValueToPtr(sqAddr_), sqMemOrderType_); - COND_RETURN_ERROR((error != RT_ERROR_NONE), error, - "Free sq addr failed, streamId=%d, deviceId=%u, ret=%d.", streamId_, deviceId, error); + error = sqAddrMemoryManage->FreeSqAddr(RtValueToPtr(sqAddr_), sqMemOrderType_); + COND_RETURN_ERROR( + (error != RT_ERROR_NONE), error, "Free sq addr failed, streamId=%d, deviceId=%u, ret=%d.", streamId_, + deviceId, error); SetSqBaseAddr(0ULL); } } if (executedTimesSvm_ != nullptr) { error = drv->MemSetSync(executedTimesSvm_, sizeof(uint16_t), 0xFFU, sizeof(uint16_t)); - COND_RETURN_ERROR(error != RT_ERROR_NONE, error, - "Set stream executed times SVM to invalid value failed, retCode=%#x.", static_cast(error)); + COND_RETURN_ERROR( + error != RT_ERROR_NONE, error, "Set stream executed times SVM to invalid value failed, retCode=%#x.", + static_cast(error)); } return RT_ERROR_NONE; } -void Stream::GetCurrentRunningTaskInfo(uint16_t &taskId, tsTaskType_t &taskType, const char_t *&taskTypeName) const +void Stream::GetCurrentRunningTaskInfo(uint16_t& taskId, tsTaskType_t& taskType, const char_t*& taskTypeName) const { taskId = MAX_UINT16_NUM; taskTypeName = "UNKNOWN"; @@ -5342,7 +5511,7 @@ void Stream::GetCurrentRunningTaskInfo(uint16_t &taskId, tsTaskType_t &taskType, return; } - TaskInfo *taskInfo = nullptr; + TaskInfo* taskInfo = nullptr; if (taskResMang_ != nullptr) { taskInfo = taskResMang_->GetTaskInfo(taskId); } @@ -5352,5 +5521,5 @@ void Stream::GetCurrentRunningTaskInfo(uint16_t &taskId, tsTaskType_t &taskType, taskType = taskInfo->type; } } -} // namespace runtime -} // namespace cce \ No newline at end of file +} // namespace runtime +} // namespace cce \ No newline at end of file diff --git a/tests/ut/runtime/runtime/test/platform/950/rt_utest_david_stream.cc b/tests/ut/runtime/runtime/test/platform/950/rt_utest_david_stream.cc index 2b3bb9f..56ac6e3 100644 --- a/tests/ut/runtime/runtime/test/platform/950/rt_utest_david_stream.cc +++ b/tests/ut/runtime/runtime/test/platform/950/rt_utest_david_stream.cc @@ -62,7 +62,7 @@ extern int64_t g_device_driver_version_stub; static rtChipType_t g_chipType; timespec g_abort_clock_time = {0, 0}; -rtError_t TaskAbortByTypeTimeoutStub(Stream *stm, uint32_t &result, const uint32_t opType, const uint32_t targetId) +rtError_t TaskAbortByTypeTimeoutStub(Stream* stm, uint32_t& result, const uint32_t opType, const uint32_t targetId) { (void)stm; (void)opType; @@ -71,7 +71,8 @@ rtError_t TaskAbortByTypeTimeoutStub(Stream *stm, uint32_t &result, const uint32 return RT_ERROR_NONE; } -rtError_t QueryAbortStatusByTypeTimeoutStub(Stream *stm, uint32_t &status, const uint32_t opType, const uint32_t targetId) +rtError_t QueryAbortStatusByTypeTimeoutStub( + Stream* stm, uint32_t& status, const uint32_t opType, const uint32_t targetId) { (void)stm; (void)opType; @@ -80,7 +81,7 @@ rtError_t QueryAbortStatusByTypeTimeoutStub(Stream *stm, uint32_t &status, const return RT_ERROR_NONE; } -int ClockGettimeAbortTimeoutStub(clockid_t clockId, struct timespec *tp) +int ClockGettimeAbortTimeoutStub(clockid_t clockId, struct timespec* tp) { (void)clockId; if (tp == nullptr) { @@ -94,7 +95,7 @@ int ClockGettimeAbortTimeoutStub(clockid_t clockId, struct timespec *tp) return 0; } -static drvError_t stubDavidGetDeviceInfo(uint32_t devId, int32_t moduleType, int32_t infoType, int64_t *value) +static drvError_t stubDavidGetDeviceInfo(uint32_t devId, int32_t moduleType, int32_t infoType, int64_t* value) { if (value) { if (moduleType == MODULE_TYPE_SYSTEM && infoType == INFO_TYPE_VERSION) { @@ -113,13 +114,13 @@ protected: static void SetUpTestCase() { MOCKER(halGetDeviceInfo).stubs().will(invoke(stubDavidGetDeviceInfo)); - char *socVer = "Ascend950PR_9599"; + char* socVer = "Ascend950PR_9599"; MOCKER(halGetSocVersion) .stubs() .with(mockcpp::any(), outBoundP(socVer, strlen("Ascend950PR_9599")), mockcpp::any()) .will(returnValue(DRV_ERROR_NONE)); std::cout << "DavidStreamTest SetUP" << std::endl; - Runtime *rtInstance = (Runtime *)Runtime::Instance(); + Runtime* rtInstance = (Runtime*)Runtime::Instance(); rtInstance->SetDisableThread(true); g_chipType = rtInstance->GetChipType(); rtInstance->SetChipType(CHIP_DAVID); @@ -130,7 +131,7 @@ protected: static void TearDownTestCase() { - Runtime *rtInstance = (Runtime *)Runtime::Instance(); + Runtime* rtInstance = (Runtime*)Runtime::Instance(); rtInstance->SetChipType(g_chipType); GlobalContainer::SetRtChipType(g_chipType); rtInstance->SetDisableThread(false); @@ -142,12 +143,12 @@ protected: { GlobalMockObject::reset(); int64_t hardwareVersion = ((ARCH_V100 << 16) | (CHIP_DAVID << 8) | (VER_NA)); - Driver *driver = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + Driver* driver = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); MOCKER_CPP_VIRTUAL(driver, &Driver::GetDevInfo) .stubs() .with(mockcpp::any(), mockcpp::any(), mockcpp::any(), outBoundP(&hardwareVersion, sizeof(hardwareVersion))) .will(returnValue(RT_ERROR_NONE)); - char *socVer = "Ascend950PR_9599"; + char* socVer = "Ascend950PR_9599"; MOCKER(halGetSocVersion) .stubs() .with(mockcpp::any(), outBoundP(socVer, strlen("Ascend950PR_9599")), mockcpp::any()) @@ -168,11 +169,11 @@ protected: rtSetDevice(0); (void)rtSetSocVersion("Ascend950PR_9599"); - ((Runtime *)Runtime::Instance())->SetIsUserSetSocVersion(false); + ((Runtime*)Runtime::Instance())->SetIsUserSetSocVersion(false); - device_ = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + device_ = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); device_->SetChipType(CHIP_DAVID); - engine_ = ((RawDevice *)device_)->engine_; + engine_ = ((RawDevice*)device_)->engine_; rtError_t res = rtStreamCreate(&streamHandle_, 0); EXPECT_EQ(res, RT_ERROR_NONE); @@ -196,16 +197,16 @@ protected: rtStreamDestroy(streamHandle_); stream_ = nullptr; engine_ = nullptr; - ((Runtime *)Runtime::Instance())->DeviceRelease(device_); - ((Runtime *)Runtime::Instance())->SetIsUserSetSocVersion(false); + ((Runtime*)Runtime::Instance())->DeviceRelease(device_); + ((Runtime*)Runtime::Instance())->SetIsUserSetSocVersion(false); rtDeviceReset(0); GlobalMockObject::reset(); } public: - Device *device_ = nullptr; - Stream *stream_ = nullptr; - Engine *engine_ = nullptr; + Device* device_ = nullptr; + Stream* stream_ = nullptr; + Engine* engine_ = nullptr; rtStream_t streamHandle_ = 0; static char function_; static uint32_t binary_[32]; @@ -216,10 +217,10 @@ uint32_t DavidStreamTest::binary_[32] = {}; TEST_F(DavidStreamTest, Apply_CntValue) { - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::NotifyIdAlloc) + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::NotifyIdAlloc) .stubs() .will(returnValue(RT_ERROR_NONE)); - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; stream->cntNotifyId_ = MAX_UINT32_NUM; int32_t cntNotifyId; rtError_t res = stream->ApplyCntNotifyId(cntNotifyId); @@ -237,8 +238,8 @@ TEST_F(DavidStreamTest, Apply_CntValue) TEST_F(DavidStreamTest, ApplyCntNotifyId_abnormal) { - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::NotifyIdAlloc).stubs().will(returnValue(1)); - DavidStream *stream = (DavidStream *)stream_; + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::NotifyIdAlloc).stubs().will(returnValue(1)); + DavidStream* stream = (DavidStream*)stream_; stream->cntNotifyId_ = MAX_UINT32_NUM; int32_t cntNotifyId; rtError_t res = stream->ApplyCntNotifyId(cntNotifyId); @@ -247,7 +248,7 @@ TEST_F(DavidStreamTest, ApplyCntNotifyId_abnormal) TEST_F(DavidStreamTest, StarsShowDfx) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; stream->publicQueueHead_ = 0U; stream->publicQueueTail_ = 0U; stream->StarsShowPublicQueueDfxInfo(); @@ -257,7 +258,7 @@ TEST_F(DavidStreamTest, StarsShowDfx) stream->StarsShowStmDfxInfo(); TaskInfo taskInfo = {}; - TaskInfo *task = &taskInfo; + TaskInfo* task = &taskInfo; InitByStream(task, stream_); AicpuTaskInit(task, 1, 0); @@ -280,7 +281,7 @@ TEST_F(DavidStreamTest, PrintStmDfxAndCheckDevice_normal) uint64_t beginCnt = 0ULL; uint64_t endCnt = 0ULL; uint16_t checkCount = 0U; - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; MOCKER_CPP_VIRTUAL(device_, &Device::GetDevRunningState).stubs().will(returnValue((uint32_t)DEV_RUNNING_NORMAL)); rtError_t res = stream->PrintStmDfxAndCheckDevice(beginCnt, endCnt, checkCount, 1000U); EXPECT_EQ(res, RT_ERROR_NONE); @@ -290,8 +291,8 @@ TEST_F(DavidStreamTest, PrintStmDfxAndCheckDevice_normal) TEST_F(DavidStreamTest, CreateStreamTaskRes) { - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); - TaskResManageDavid *task = new (std::nothrow) TaskResManageDavid(); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); + TaskResManageDavid* task = new (std::nothrow) TaskResManageDavid(); MOCKER_CPP_VIRTUAL(task, &TaskResManageDavid::CreateTaskRes).stubs().will(returnValue(false)); rtError_t res = stream->CreateStreamTaskRes(); EXPECT_NE(res, RT_ERROR_NONE); @@ -301,8 +302,8 @@ TEST_F(DavidStreamTest, CreateStreamTaskRes) TEST_F(DavidStreamTest, AbortStreamTearDown) { - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); - TaskResManageDavid *task = new (std::nothrow) TaskResManageDavid(); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); + TaskResManageDavid* task = new (std::nothrow) TaskResManageDavid(); MOCKER_CPP_VIRTUAL(task, &TaskResManageDavid::CreateTaskRes).stubs().will(returnValue(false)); device_->SetDeviceStatus(RT_ERROR_DEVICE_TASK_ABORT); rtError_t res = stream->CreateStreamTaskRes(); @@ -317,7 +318,7 @@ TEST_F(DavidStreamTest, PrintStmDfxAndCheckDevice_abnormal) uint64_t beginCnt = 0ULL; uint64_t endCnt = 0ULL; uint16_t checkCount = 0U; - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; MOCKER_CPP_VIRTUAL(device_, &Device::GetDevRunningState).stubs().will(returnValue((uint32_t)DEV_RUNNING_DOWN)); rtError_t res = stream->PrintStmDfxAndCheckDevice(beginCnt, endCnt, checkCount, 1000U); EXPECT_EQ(res, RT_ERROR_DRV_ERR); @@ -325,7 +326,7 @@ TEST_F(DavidStreamTest, PrintStmDfxAndCheckDevice_abnormal) TEST_F(DavidStreamTest, setup_checkgroup) { - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); MOCKER_CPP(&Stream::CheckGroup).stubs().will(returnValue(1)); rtError_t res = stream->Setup(); EXPECT_NE(res, RT_ERROR_NONE); @@ -334,7 +335,7 @@ TEST_F(DavidStreamTest, setup_checkgroup) TEST_F(DavidStreamTest, setup_forbidden) { - DavidStream *stream = new DavidStream(device_, 0, RT_STREAM_FORBIDDEN_DEFAULT, nullptr); + DavidStream* stream = new DavidStream(device_, 0, RT_STREAM_FORBIDDEN_DEFAULT, nullptr); MOCKER_CPP(&StreamSqCqManage::AllocDavidStreamSqCq).stubs().will(returnValue(1)); rtError_t res = stream->Setup(); EXPECT_EQ(res, RT_ERROR_NONE); @@ -359,8 +360,8 @@ TEST_F(DavidStreamTest, setup_persisit_logic_alloc) TEST_F(DavidStreamTest, setup_persisit_modelexe) { - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) .stubs() .will(returnValue(1)); rtStream_t stream = 0; @@ -370,11 +371,11 @@ TEST_F(DavidStreamTest, setup_persisit_modelexe) TEST_F(DavidStreamTest, setup_persisit_modelexe_suc) { - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) .stubs() .will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::MemCopySync).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::MemCopySync).stubs().will(returnValue(0)); rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, RT_STREAM_PERSISTENT); EXPECT_EQ(res, RT_ERROR_NONE); @@ -383,71 +384,61 @@ TEST_F(DavidStreamTest, setup_persisit_modelexe_suc) TEST_F(DavidStreamTest, auto_split_stream_destroy) { - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::DevMemAlloc) + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) .stubs() .will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) - .stubs() - .will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::MemCopySync) - .stubs() - .will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::SqSwitchStreamBatch) - .stubs() - .will(returnValue(0)); - MOCKER_CPP(&SqAddrMemoryOrder::FreeSqAddr) - .stubs() - .will(returnValue(RT_ERROR_NONE)); - MOCKER_CPP(&DeviceSqCqPool::FreeSqCqToDrv) - .stubs() - .will(returnValue(RT_ERROR_NONE)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::MemCopySync).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::SqSwitchStreamBatch).stubs().will(returnValue(0)); + MOCKER_CPP(&SqAddrMemoryOrder::FreeSqAddr).stubs().will(returnValue(RT_ERROR_NONE)); + MOCKER_CPP(&DeviceSqCqPool::FreeSqCqToDrv).stubs().will(returnValue(RT_ERROR_NONE)); rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, RT_STREAM_PERSISTENT); EXPECT_EQ(res, RT_ERROR_NONE); - Stream *realStream = rt_ut::UnwrapOrNull(stream); + Stream* realStream = rt_ut::UnwrapOrNull(stream); ASSERT_NE(realStream, nullptr); realStream->SetAutoSplitSq(true); - AutoSplitSqContext *autoSplitCtx_ = new (std::nothrow) AutoSplitSqContext(); + AutoSplitSqContext* autoSplitCtx_ = new (std::nothrow) AutoSplitSqContext(); autoSplitCtx_->curStreamSqeCount = 0U; realStream->SetIsSlaveStream(false); realStream->SetAutoSplitCtx(autoSplitCtx_); realStream->SetSqBaseAddr(100); realStream->streamSwitchInfo_ = new (std::nothrow) struct sq_switch_stream_info[1U](); - Stream *stream2 = nullptr; + Stream* stream2 = nullptr; realStream->Context_()->CreateAutoSplitSlaveStream(realStream, &stream2); - autoSplitCtx_->slaveStreams.push_back((Stream *)stream2); + autoSplitCtx_->slaveStreams.push_back((Stream*)stream2); rtStreamDestroy(stream); } TEST_F(DavidStreamTest, auto_split_task_clean) { - void *mockSvmAddr = reinterpret_cast(0x1000); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::DevMemAlloc) + void* mockSvmAddr = reinterpret_cast(0x1000); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::DevMemAlloc) .stubs() .with(outBoundP(&mockSvmAddr), mockcpp::any(), mockcpp::any(), mockcpp::any()) .will(returnValue(0)); bool enable = false; - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::GetSqEnable) + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::GetSqEnable) .stubs() .with(mockcpp::any(), mockcpp::any(), mockcpp::any(), outBound(enable)) .will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::MemCopySync).stubs().will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::MemSetSync).stubs().will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::SqSwitchStreamBatch).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::MemCopySync).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::MemSetSync).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::SqSwitchStreamBatch).stubs().will(returnValue(0)); MOCKER_CPP(&Model::UnbindStream).stubs().will(returnValue(RT_ERROR_NONE)); MOCKER_CPP(&Model::ModelUnBindTaskSubmit).stubs().will(returnValue(RT_ERROR_NONE)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::DevMemFree).stubs().will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::StreamIdReservedFree).stubs().will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::ReAllocResourceId).stubs().will(returnValue(0)); - SqAddrMemoryOrder *sqAddrMemoryManage = nullptr; + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::DevMemFree).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::StreamIdReservedFree).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::ReAllocResourceId).stubs().will(returnValue(0)); + SqAddrMemoryOrder* sqAddrMemoryManage = nullptr; MOCKER_CPP_VIRTUAL(device_, &Device::GetSqAddrMemoryManage).stubs().will(returnValue(sqAddrMemoryManage)); rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, RT_STREAM_PERSISTENT); EXPECT_EQ(res, RT_ERROR_NONE); - Stream *realStream = rt_ut::UnwrapOrNull(stream); + Stream* realStream = rt_ut::UnwrapOrNull(stream); ASSERT_NE(realStream, nullptr); realStream->SetAutoSplitSq(true); - AutoSplitSqContext *autoSplitCtx_ = new (std::nothrow) AutoSplitSqContext(); + AutoSplitSqContext* autoSplitCtx_ = new (std::nothrow) AutoSplitSqContext(); realStream->SetIsSlaveStream(false); realStream->SetAutoSplitCtx(autoSplitCtx_); realStream->SetSqBaseAddr(100); @@ -458,13 +449,11 @@ TEST_F(DavidStreamTest, auto_split_task_clean) EXPECT_EQ(error, RT_ERROR_NONE); error = rtModelBindStream(rtModel, stream, 0); EXPECT_EQ(error, RT_ERROR_NONE); - Stream *stream2 = nullptr; + Stream* stream2 = nullptr; realStream->Context_()->CreateAutoSplitSlaveStream(realStream, &stream2); - autoSplitCtx_->slaveStreams.push_back((Stream *)stream2); - MOCKER_CPP_VIRTUAL(realStream->Context_(), &Context::TearDownStream) - .stubs() - .will(returnValue(0)); - error = static_cast(realStream)->StreamTaskClean(); + autoSplitCtx_->slaveStreams.push_back((Stream*)stream2); + MOCKER_CPP_VIRTUAL(realStream->Context_(), &Context::TearDownStream).stubs().will(returnValue(0)); + error = static_cast(realStream)->StreamTaskClean(); EXPECT_EQ(error, RT_ERROR_NONE); rtModelUnbindStream(rtModel, stream); rtStreamDestroy(stream); @@ -472,7 +461,7 @@ TEST_F(DavidStreamTest, auto_split_task_clean) TEST_F(DavidStreamTest, setup_aicpu) { - DavidStream *stream = new DavidStream(device_, 0, RT_STREAM_AICPU, nullptr); + DavidStream* stream = new DavidStream(device_, 0, RT_STREAM_AICPU, nullptr); rtError_t res = stream->Setup(); EXPECT_EQ(res, RT_ERROR_NONE); delete stream; @@ -491,7 +480,7 @@ TEST_F(DavidStreamTest, setup_normal_delete) rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, 0); EXPECT_EQ(res, RT_ERROR_NONE); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); (rt_ut::UnwrapOrNull(stream))->GetDvppRRTaskAddr(); (rt_ut::UnwrapOrNull(stream))->SetSubscribeFlag(StreamSubscribeFlag::SUBSCRIBE_USER); rtStreamDestroy(stream); @@ -512,12 +501,12 @@ TEST_F(DavidStreamTest, setup_cnt_free_fail) rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, 0); EXPECT_EQ(res, RT_ERROR_NONE); - DavidStream *davidStream = (DavidStream *)(rt_ut::UnwrapOrNull(stream)); + DavidStream* davidStream = (DavidStream*)(rt_ut::UnwrapOrNull(stream)); davidStream->cntNotifyId_ = MAX_UINT32_NUM; int32_t cntNotifyId; res = davidStream->ApplyCntNotifyId(cntNotifyId); EXPECT_EQ(res, RT_ERROR_NONE); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::NotifyIdFree).stubs().will(returnValue(1)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::NotifyIdFree).stubs().will(returnValue(1)); rtStreamDestroy(stream); } @@ -526,7 +515,7 @@ TEST_F(DavidStreamTest, public_queue) rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, 0); EXPECT_EQ(res, RT_ERROR_NONE); - DavidStream *davidStream = (DavidStream *)(rt_ut::UnwrapOrNull(stream)); + DavidStream* davidStream = (DavidStream*)(rt_ut::UnwrapOrNull(stream)); (rt_ut::UnwrapOrNull(stream))->taskPublicBuffSize_ = 0U; res = davidStream->DavidUpdatePublicQueue(); EXPECT_NE(res, RT_ERROR_NONE); @@ -535,7 +524,7 @@ TEST_F(DavidStreamTest, public_queue) EXPECT_NE(res, RT_ERROR_NONE); davidStream->publicQueueHead_ = 0; davidStream->publicQueueTail_ = 1; - TaskResManageDavid *taskResMang = ((TaskResManageDavid *)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); + TaskResManageDavid* taskResMang = ((TaskResManageDavid*)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); taskResMang->taskResATail_.Set(10); (rt_ut::UnwrapOrNull(stream))->taskPublicBuff_[0] = 6; uint16_t endRecylePos = 5; @@ -557,12 +546,14 @@ TEST_F(DavidStreamTest, public_queue) } TEST_F(DavidStreamTest, npu_driver_sw_success) { - NpuDriver *driver = (NpuDriver *)device_->Driver_(); + NpuDriver* driver = (NpuDriver*)device_->Driver_(); uint32_t version; size_t ackCount = sizeof(ts_ctrl_msg_body_t); MOCKER(halTsdrvCtl) .stubs() - .with(mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), outBoundP(&ackCount, sizeof(ackCount))) + .with( + mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + outBoundP(&ackCount, sizeof(ackCount))) .will(returnValue(DRV_ERROR_NONE)); rtError_t res = driver->GetTsfwVersion(0, 0, version); EXPECT_EQ(res, RT_ERROR_NONE); @@ -570,7 +561,7 @@ TEST_F(DavidStreamTest, npu_driver_sw_success) TEST_F(DavidStreamTest, npu_driver_sw_fail) { - NpuDriver *driver = (NpuDriver *)device_->Driver_(); + NpuDriver* driver = (NpuDriver*)device_->Driver_(); uint32_t version; MOCKER(halTsdrvCtl).stubs().will(returnValue(1)); rtError_t res = driver->GetTsfwVersion(0, 0, version); @@ -579,11 +570,11 @@ TEST_F(DavidStreamTest, npu_driver_sw_fail) TEST_F(DavidStreamTest, ResClear_01) { - DavidStream *stream = new DavidStream(device_, 0, RT_STREAM_AICPU, nullptr); + DavidStream* stream = new DavidStream(device_, 0, RT_STREAM_AICPU, nullptr); rtError_t ret = stream->Setup(); EXPECT_EQ(ret, RT_ERROR_NONE); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::NotifyIdFree).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::NotifyIdFree).stubs().will(returnValue(0)); MOCKER_CPP_VIRTUAL(device_, &Device::GetDevRunningState) .stubs() @@ -603,21 +594,17 @@ TEST_F(DavidStreamTest, DavidrtStreamTaskAbort_01) rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, 0); EXPECT_EQ(res, RT_ERROR_NONE); - DavidStream *davidStream = (DavidStream *)(rt_ut::UnwrapOrNull(stream)); + DavidStream* davidStream = (DavidStream*)(rt_ut::UnwrapOrNull(stream)); - MOCKER_CPP(&Context::IsStreamAbortSupported) - .stubs() - .will(returnValue(true)); - - MOCKER(halSqCqConfig) - .stubs() - .will(returnValue(DRV_ERROR_NONE)); + MOCKER_CPP(&Context::IsStreamAbortSupported).stubs().will(returnValue(true)); + + MOCKER(halSqCqConfig).stubs().will(returnValue(DRV_ERROR_NONE)); g_abort_clock_time = {0, 0}; MOCKER(clock_gettime).stubs().will(invoke(ClockGettimeAbortTimeoutStub)); - MOCKER_CPP_VIRTUAL(static_cast(davidStream), &Stream::TaskAbortByType) + MOCKER_CPP_VIRTUAL(static_cast(davidStream), &Stream::TaskAbortByType) .stubs() .will(invoke(TaskAbortByTypeTimeoutStub)); - MOCKER_CPP_VIRTUAL(static_cast(davidStream), &Stream::QueryAbortStatusByType) + MOCKER_CPP_VIRTUAL(static_cast(davidStream), &Stream::QueryAbortStatusByType) .stubs() .will(invoke(QueryAbortStatusByTypeTimeoutStub)); rtError_t error = davidStream->StreamAbort(); @@ -628,8 +615,9 @@ TEST_F(DavidStreamTest, DavidrtStreamTaskAbort_01) uint32_t gabort_times = 0U; uint32_t gquery_times = 0U; -rtError_t TaskAbortByTypeByTimes(NpuDriver *drv, const uint32_t deviceId, const uint32_t tsId, const uint32_t opType, - const uint32_t targetId, uint32_t &result) +rtError_t TaskAbortByTypeByTimes( + NpuDriver* drv, const uint32_t deviceId, const uint32_t tsId, const uint32_t opType, const uint32_t targetId, + uint32_t& result) { if (gabort_times == 0U) { result = 0x115; @@ -639,9 +627,10 @@ rtError_t TaskAbortByTypeByTimes(NpuDriver *drv, const uint32_t deviceId, const gabort_times++; return RT_ERROR_NONE; } - -rtError_t QueryAbortStatusByTypeByTimes(NpuDriver *drv, const uint32_t deviceId, const uint32_t tsId, const uint32_t queryType, - const uint32_t targetId, uint32_t &status) + +rtError_t QueryAbortStatusByTypeByTimes( + NpuDriver* drv, const uint32_t deviceId, const uint32_t tsId, const uint32_t queryType, const uint32_t targetId, + uint32_t& status) { if (gquery_times == 0U) { status = 1; @@ -659,7 +648,7 @@ TEST_F(DavidStreamTest, DavidrtStreamStop_01) rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, 0); EXPECT_EQ(res, RT_ERROR_NONE); - DavidStream *davidStream = (DavidStream *)(rt_ut::UnwrapOrNull(stream)); + DavidStream* davidStream = (DavidStream*)(rt_ut::UnwrapOrNull(stream)); davidStream->SetBindFlag(true); rtError_t error = rtsStreamStop(stream); @@ -675,18 +664,12 @@ TEST_F(DavidStreamTest, DavidrtStreamStop_02) EXPECT_EQ(res, RT_ERROR_NONE); gabort_times = 0U; gquery_times = 0U; - MOCKER(halSqCqConfig) - .stubs() - .will(returnValue(DRV_ERROR_NONE)); + MOCKER(halSqCqConfig).stubs().will(returnValue(DRV_ERROR_NONE)); NpuDriver drv; - MOCKER_CPP_VIRTUAL(drv, &NpuDriver::TaskAbortByType) - .stubs() - .will(invoke(TaskAbortByTypeByTimes)); + MOCKER_CPP_VIRTUAL(drv, &NpuDriver::TaskAbortByType).stubs().will(invoke(TaskAbortByTypeByTimes)); - MOCKER_CPP_VIRTUAL(drv, &NpuDriver::QueryAbortStatusByType) - .stubs() - .will(invoke(QueryAbortStatusByTypeByTimes)); + MOCKER_CPP_VIRTUAL(drv, &NpuDriver::QueryAbortStatusByType).stubs().will(invoke(QueryAbortStatusByTypeByTimes)); rtError_t error = rtsStreamStop(stream); EXPECT_EQ(error, RT_ERROR_NONE); error = rtStreamDestroy(stream); @@ -698,12 +681,10 @@ TEST_F(DavidStreamTest, DavidrtStreamStop_03) rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, 0); EXPECT_EQ(res, RT_ERROR_NONE); - DavidStream *davidStream = (DavidStream *)(rt_ut::UnwrapOrNull(stream)); + DavidStream* davidStream = (DavidStream*)(rt_ut::UnwrapOrNull(stream)); ApiImpl impl; ApiDecorator apiDecorator(&impl); - MOCKER_CPP_VIRTUAL(impl, &ApiImpl::StreamClear) - .stubs() - .will(returnValue(RT_ERROR_NONE)); + MOCKER_CPP_VIRTUAL(impl, &ApiImpl::StreamClear).stubs().will(returnValue(RT_ERROR_NONE)); rtError_t error = apiDecorator.StreamStop(davidStream); EXPECT_EQ(error, RT_ERROR_NONE); error = rtStreamDestroy(stream); @@ -713,58 +694,58 @@ TEST_F(DavidStreamTest, DavidrtStreamStop_03) TEST_F(DavidStreamTest, AddArgHandleToRecycleList_Normal) { // 测试正常添加 argHandle - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); void* handle1 = reinterpret_cast(0x12345678); void* handle2 = reinterpret_cast(0x87654321); - + stream->AddArgHandleToRecycleList(handle1); stream->AddArgHandleToRecycleList(handle2); - + EXPECT_EQ(stream->argHandleRecycleList_.size(), 2U); EXPECT_EQ(stream->argHandleRecycleList_[0], handle1); EXPECT_EQ(stream->argHandleRecycleList_[1], handle2); - + delete stream; } TEST_F(DavidStreamTest, AddArgHandleToRecycleList_Nullptr) { // 测试添加 nullptr - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); - + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); + stream->AddArgHandleToRecycleList(nullptr); - + EXPECT_EQ(stream->argHandleRecycleList_.size(), 0U); - + delete stream; } TEST_F(DavidStreamTest, Destructor_ArgHandleRecycleList) { // 测试析构函数中回收 argHandleRecycleList_ - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); void* handle1 = reinterpret_cast(0x12345678); void* handle2 = reinterpret_cast(0x87654321); - + stream->argHandleRecycleList_.push_back(handle1); stream->argHandleRecycleList_.push_back(handle2); - + // mock RecycleDevLoader if (stream->argManage_ != nullptr) { MOCKER_CPP_VIRTUAL(stream->argManage_, &StarsArgManager::RecycleDevLoader) .stubs() .will(returnValue(RT_ERROR_NONE)); } - + delete stream; } TEST_F(DavidStreamTest, DavidrtStreamRecover_01) { - RawDevice *device = new RawDevice(0); + RawDevice* device = new RawDevice(0); device->Init(); - DavidStream *stream = new DavidStream(device, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device, 0, 0, nullptr); NpuDriver drv; MOCKER_CPP_VIRTUAL(drv, &NpuDriver::RecoverAbortByType).stubs().will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(drv, &NpuDriver::QueryRecoverStatusByType).stubs().will(returnValue(RT_ERROR_NONE)); @@ -780,13 +761,13 @@ TEST_F(DavidStreamTest, DavidrtModelAbortByid) { int32_t devId; rtError_t error; - Context *ctx; + Context* ctx; error = rtGetDevice(&devId); EXPECT_EQ(error, RT_ERROR_NONE); - RefObject *refObject = NULL; - refObject = (RefObject *)((Runtime *)Runtime::Instance())->PrimaryContextRetain(devId); + RefObject* refObject = NULL; + refObject = (RefObject*)((Runtime*)Runtime::Instance())->PrimaryContextRetain(devId); ctx = refObject->GetVal(); NpuDriver drv; @@ -796,29 +777,29 @@ TEST_F(DavidStreamTest, DavidrtModelAbortByid) error = ctx->ModelAbortById(1); EXPECT_EQ(error, RT_ERROR_WAIT_TIMEOUT); - (void)((Runtime *)Runtime::Instance())->PrimaryContextRelease(devId); + (void)((Runtime*)Runtime::Instance())->PrimaryContextRelease(devId); } TEST_F(DavidStreamTest, record_task_fail_0) { MOCKER(AllocTaskInfo).stubs().will(returnValue(RT_ERROR_INVALID_VALUE)); - rtError_t res = ((DavidStream *)stream_)->SubmitRecordTask(200); + rtError_t res = ((DavidStream*)stream_)->SubmitRecordTask(200); EXPECT_NE(res, RT_ERROR_NONE); } TEST_F(DavidStreamTest, maintence_task) { - rtDavidSqe_t *sqe = (rtDavidSqe_t *)malloc(sizeof(rtDavidSqe_t)); + rtDavidSqe_t* sqe = (rtDavidSqe_t*)malloc(sizeof(rtDavidSqe_t)); uint64_t oldSqAddr = stream_->GetSqBaseAddr(); uint64_t newSqAddr = reinterpret_cast(sqe); stream_->Device_()->GetStreamSqCqManage()->sqIdToStreamIdMap_[0] = stream_->Id_(); stream_->SetSqBaseAddr(newSqAddr); - TaskResManageDavid *taskResMang = ((TaskResManageDavid *)(static_cast(stream_)->taskResMang_)); + TaskResManageDavid* taskResMang = ((TaskResManageDavid*)(static_cast(stream_)->taskResMang_)); TaskInfo reportTask = {}; reportTask.taskSn = 0U; reportTask.stream = stream_; MOCKER(GetTaskInfo).stubs().will(returnValue(&reportTask)); - rtError_t res = ((DavidStream *)stream_)->SubmitMaintenanceTask(MT_STREAM_RECYCLE_TASK, false, 0, 0, false); + rtError_t res = ((DavidStream*)stream_)->SubmitMaintenanceTask(MT_STREAM_RECYCLE_TASK, false, 0, 0, false); EXPECT_EQ(res, RT_ERROR_NONE); taskResMang->ResetTaskRes(); stream_->SetSqBaseAddr(oldSqAddr); @@ -828,7 +809,7 @@ TEST_F(DavidStreamTest, maintence_task) TEST_F(DavidStreamTest, record_task_fail_1) { MOCKER(ProcStreamRecordTask).stubs().will(returnValue(RT_ERROR_STREAM_SYNC_TIMEOUT)); - rtError_t res = ((DavidStream *)stream_)->SubmitRecordTask(200); + rtError_t res = ((DavidStream*)stream_)->SubmitRecordTask(200); EXPECT_NE(res, RT_ERROR_NONE); } @@ -836,13 +817,13 @@ TEST_F(DavidStreamTest, SYNCHRONIZE_TEST_DAVID) { int32_t devId; rtError_t error; - Context *ctx; + Context* ctx; error = rtGetDevice(&devId); EXPECT_EQ(error, RT_ERROR_NONE); - RefObject *refObject = NULL; - refObject = (RefObject *)((Runtime *)Runtime::Instance())->PrimaryContextRetain(devId); + RefObject* refObject = NULL; + refObject = (RefObject*)((Runtime*)Runtime::Instance())->PrimaryContextRetain(devId); ctx = refObject->GetVal(); bool ret = ctx->IsStreamNotSync(RT_STREAM_CP_PROCESS_USE); @@ -854,7 +835,7 @@ TEST_F(DavidStreamTest, SYNCHRONIZE_TEST_DAVID) ret = ctx->IsStreamNotSync(RT_STREAM_DEFAULT); EXPECT_EQ(ret, false); - (void)((Runtime *)Runtime::Instance())->PrimaryContextRelease(devId); + (void)((Runtime*)Runtime::Instance())->PrimaryContextRelease(devId); } TEST_F(DavidStreamTest, davidstream_IsReclaimAsync) @@ -863,11 +844,11 @@ TEST_F(DavidStreamTest, davidstream_IsReclaimAsync) rtStream_t stream; rtContext_t ctx; TaskInfo tsk = {}; - Runtime *rtInstance = (Runtime *)Runtime::Instance(); + Runtime* rtInstance = (Runtime*)Runtime::Instance(); error = rtStreamCreate(&stream, 0); EXPECT_EQ(error, RT_ERROR_NONE); - DavidStream *stream_var = (DavidStream *)(rt_ut::UnwrapOrNull(stream)); + DavidStream* stream_var = (DavidStream*)(rt_ut::UnwrapOrNull(stream)); tsk.type = TS_TASK_TYPE_NOTIFY_WAIT; bool ret = stream_var->IsReclaimAsync(&tsk); @@ -899,14 +880,12 @@ TEST_F(DavidStreamTest, davidstream_IsReclaimAsync) TEST_F(DavidStreamTest, TestCreateStreamAndGet) { - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) .stubs() .will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::MemCopySync).stubs().will(returnValue(0)); - MOCKER_CPP_VIRTUAL(device_, &Device::CheckFeatureSupport) - .stubs() - .will(returnValue(true)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::MemCopySync).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL(device_, &Device::CheckFeatureSupport).stubs().will(returnValue(true)); rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, RT_STREAM_CP_PROCESS_USE); EXPECT_EQ(res, RT_ERROR_NONE); @@ -918,18 +897,12 @@ TEST_F(DavidStreamTest, TestCreateStreamAndGet) TEST_F(DavidStreamTest, TestCreateAutoSplitStreamAndGet) { MOCKER_CPP(&Stream::AllocExecutedTimesSvm).stubs().will(returnValue(RT_ERROR_NONE)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::DevMemAlloc) - .stubs() - .will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::DevMemAlloc).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::GetSqRegVirtualAddrBySqid) .stubs() .will(returnValue(0)); - MOCKER_CPP_VIRTUAL((NpuDriver *)device_->Driver_(), &NpuDriver::MemCopySync) - .stubs() - .will(returnValue(0)); - MOCKER_CPP_VIRTUAL(device_, &Device::CheckFeatureSupport) - .stubs() - .will(returnValue(true)); + MOCKER_CPP_VIRTUAL((NpuDriver*)device_->Driver_(), &NpuDriver::MemCopySync).stubs().will(returnValue(0)); + MOCKER_CPP_VIRTUAL(device_, &Device::CheckFeatureSupport).stubs().will(returnValue(true)); rtStream_t stream = 0; rtError_t res = rtStreamCreateWithFlags(&stream, 0, RT_STREAM_PERSISTENT); EXPECT_EQ(res, RT_ERROR_NONE); @@ -940,36 +913,37 @@ TEST_F(DavidStreamTest, TestCreateAutoSplitStreamAndGet) TEST_F(DavidStreamTest, IsTaskExcuted_Test) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; uint32_t executeEndTaskid = 10; uint32_t taskId = 5; bool result = stream->IsTaskExcuted(executeEndTaskid, taskId); EXPECT_EQ(result, true); } - + TEST_F(DavidStreamTest, SeparateSendAndRecycleError) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; MOCKER_CPP(&Stream::IsSeparateSendAndRecycle).stubs().will(returnValue(true)); rtError_t error = stream->ResClear(); EXPECT_EQ(error, RT_ERROR_NONE); } - -TEST_F(DavidStreamTest, TestSeparateSendAndRecycle3) { - DavidStream *stream = (DavidStream *)stream_; + +TEST_F(DavidStreamTest, TestSeparateSendAndRecycle3) +{ + DavidStream* stream = (DavidStream*)stream_; rtError_t ret; MOCKER_CPP(&Stream::IsSeparateSendAndRecycle).stubs().will(returnValue(true)); stream->SetBindFlag(false); stream->SetExecuteEndTaskId(0); ret = SubmitTaskPostProc(stream, 0, true, 100); - EXPECT_EQ(ret, RT_ERROR_NONE); + EXPECT_EQ(ret, RT_ERROR_NONE); } - + TEST_F(DavidStreamTest, GetTaskPosHead_taskResMangIsNull) { - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); uint32_t posHead = stream->GetTaskPosHead(); EXPECT_EQ(posHead, 0U); delete stream; @@ -977,7 +951,7 @@ TEST_F(DavidStreamTest, GetTaskPosHead_taskResMangIsNull) TEST_F(DavidStreamTest, GetTaskPosTail_taskResMangIsNull) { - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); uint32_t posTail = stream->GetTaskPosTail(); EXPECT_EQ(posTail, 0U); delete stream; @@ -985,48 +959,46 @@ TEST_F(DavidStreamTest, GetTaskPosTail_taskResMangIsNull) TEST_F(DavidStreamTest, SeparateSendAndRecycleError2) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; MOCKER_CPP(&Stream::IsSeparateSendAndRecycle).stubs().will(returnValue(true)); - + rtError_t error = stream->ResClear(); EXPECT_EQ(error, RT_ERROR_NONE); } TEST_F(DavidStreamTest, TestSeparateSendAndRecycle4) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; rtError_t ret; MOCKER_CPP(&Stream::IsSeparateSendAndRecycle).stubs().will(returnValue(true)); stream->SetBindFlag(false); stream->SetExecuteEndTaskId(0); ret = SubmitTaskPostProc(stream, 0, true, 100); - EXPECT_EQ(ret, RT_ERROR_NONE); + EXPECT_EQ(ret, RT_ERROR_NONE); } TEST_F(DavidStreamTest, TestSyncDelayTime) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; uint16_t finishedId = 10U; uint16_t taskId = 30U; bool isFinish = stream->SynchronizeDelayTime(finishedId, taskId); - EXPECT_EQ(isFinish, false); + EXPECT_EQ(isFinish, false); finishedId = 25U; isFinish = stream->SynchronizeDelayTime(finishedId, taskId); - EXPECT_EQ(isFinish, true); + EXPECT_EQ(isFinish, true); - MOCKER_CPP_VIRTUAL((DavidStream*)stream, &DavidStream::IsTaskExcuted) - .stubs() - .will(returnValue(false)); + MOCKER_CPP_VIRTUAL((DavidStream*)stream, &DavidStream::IsTaskExcuted).stubs().will(returnValue(false)); isFinish = stream->SynchronizeDelayTime(finishedId, taskId); - EXPECT_EQ(isFinish, false); + EXPECT_EQ(isFinish, false); } TEST_F(DavidStreamTest, SynchronizeDelayTime_DistanceGte10) { - DavidStream *stream = (DavidStream *)stream_; - TaskResManageDavid *taskResMng = dynamic_cast(stream->taskResMang_); + DavidStream* stream = (DavidStream*)stream_; + TaskResManageDavid* taskResMng = dynamic_cast(stream->taskResMang_); ASSERT_NE(taskResMng, nullptr); taskResMng->taskPoolNum_ = 2049; @@ -1041,8 +1013,8 @@ TEST_F(DavidStreamTest, SynchronizeDelayTime_DistanceGte10) TEST_F(DavidStreamTest, SynchronizeDelayTime_IsTaskExcutedTrue) { - DavidStream *stream = (DavidStream *)stream_; - TaskResManageDavid *taskResMng = dynamic_cast(stream->taskResMang_); + DavidStream* stream = (DavidStream*)stream_; + TaskResManageDavid* taskResMng = dynamic_cast(stream->taskResMang_); ASSERT_NE(taskResMng, nullptr); taskResMng->taskPoolNum_ = 2049; @@ -1066,8 +1038,8 @@ TEST_F(DavidStreamTest, SynchronizeDelayTime_IsTaskExcutedTrue) TEST_F(DavidStreamTest, SynchronizeDelayTime_WrapAround_IsTaskExcutedTrue) { - DavidStream *stream = (DavidStream *)stream_; - TaskResManageDavid *taskResMng = dynamic_cast(stream->taskResMang_); + DavidStream* stream = (DavidStream*)stream_; + TaskResManageDavid* taskResMng = dynamic_cast(stream->taskResMang_); ASSERT_NE(taskResMng, nullptr); taskResMng->taskPoolNum_ = 2049; @@ -1091,8 +1063,8 @@ TEST_F(DavidStreamTest, SynchronizeDelayTime_WrapAround_IsTaskExcutedTrue) TEST_F(DavidStreamTest, SynchronizeDelayTime_WrapAround_IsTaskExcutedFalse) { - DavidStream *stream = (DavidStream *)stream_; - TaskResManageDavid *taskResMng = dynamic_cast(stream->taskResMang_); + DavidStream* stream = (DavidStream*)stream_; + TaskResManageDavid* taskResMng = dynamic_cast(stream->taskResMang_); ASSERT_NE(taskResMng, nullptr); taskResMng->taskPoolNum_ = 2049; @@ -1116,26 +1088,26 @@ TEST_F(DavidStreamTest, SynchronizeDelayTime_WrapAround_IsTaskExcutedFalse) TEST_F(DavidStreamTest, ExpandStreamRecycleModelBindStreamAllTask) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; - Stream *stream_var = stream_; + Stream* stream_var = stream_; stream_var->pendingNum_.Set(0); stream_var->delayRecycleTaskid_.push_back(0); - std::cout<<"stream create success."<ExpandStreamRecycleModelBindStreamAllTask(cleanFlag); + stream->ExpandStreamRecycleModelBindStreamAllTask(cleanFlag); } TEST_F(DavidStreamTest, ExpandStreamRecycleModelBindStreamAllTask_WithLabelSet) { - DavidStream *stream = (DavidStream *)stream_; - TaskResManageDavid *taskResMang = dynamic_cast(stream->taskResMang_); + DavidStream* stream = (DavidStream*)stream_; + TaskResManageDavid* taskResMang = dynamic_cast(stream->taskResMang_); ASSERT_NE(taskResMang, nullptr); stream->SetBindFlag(true); // 分配一个任务 - TaskInfo *task = nullptr; + TaskInfo* task = nullptr; uint32_t pos = 0U; rtError_t error = taskResMang->AllocTaskInfoAndPos(1U, pos, &task); ASSERT_EQ(error, RT_ERROR_NONE); @@ -1147,7 +1119,7 @@ TEST_F(DavidStreamTest, ExpandStreamRecycleModelBindStreamAllTask_WithLabelSet) ASSERT_EQ(error, RT_ERROR_NONE); // 创建 Label 并添加到 stream 的 labels_ 列表 - Label *label = new Label(nullptr); + Label* label = new Label(nullptr); label->context_ = stream->Context_(); label->labelId_ = 0; label->setFlag_ = true; @@ -1168,7 +1140,7 @@ TEST_F(DavidStreamTest, ExpandStreamRecycleModelBindStreamAllTask_WithLabelSet) TEST_F(DavidStreamTest, RecordPosToTaskIdMap) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; stream->publicQueueHead_ = 0U; stream->publicQueueTail_ = 0U; stream->StarsShowPublicQueueDfxInfo(); @@ -1177,7 +1149,7 @@ TEST_F(DavidStreamTest, RecordPosToTaskIdMap) stream->StarsShowPublicQueueDfxInfo(); stream->StarsShowStmDfxInfo(); TaskInfo taskInfo = {}; - TaskInfo *task = &taskInfo; + TaskInfo* task = &taskInfo; InitByStream(task, stream_); AicpuTaskInit(task, 1, 0); @@ -1189,14 +1161,14 @@ TEST_F(DavidStreamTest, RecordPosToTaskIdMap) TEST_F(DavidStreamTest, HandleTaskUpdate) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; MOCKER_CPP(&Stream::StarsAddTaskToStreamForModelUpdate).stubs().will(returnValue(RT_ERROR_NONE)); CaptureModel captureModel(RT_MODEL_CAPTURE_MODEL); uint8_t sqeBuffer[100]; TaskInfo taskInfo = {}; - TaskInfo *task = &taskInfo; + TaskInfo* task = &taskInfo; captureModel.context_ = stream->Context_(); InitByStream(task, stream_); @@ -1208,10 +1180,10 @@ TEST_F(DavidStreamTest, HandleTaskUpdate) TEST_F(DavidStreamTest, HandleTaskDisable) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; CaptureModel captureModel(RT_MODEL_CAPTURE_MODEL); TaskInfo taskInfo = {}; - TaskInfo *task = &taskInfo; + TaskInfo* task = &taskInfo; captureModel.context_ = stream->Context_(); InitByStream(task, stream_); @@ -1225,14 +1197,14 @@ TEST_F(DavidStreamTest, HandleTaskDisable) TEST_F(DavidStreamTest, HandleTaskDefault) { - DavidStream *stream = (DavidStream *)stream_; + DavidStream* stream = (DavidStream*)stream_; MOCKER_CPP(&Stream::StarsAddTaskToStreamForModelUpdate).stubs().will(returnValue(RT_ERROR_NONE)); CaptureModel captureModel(RT_MODEL_CAPTURE_MODEL); uint8_t sqeBuffer1[200]; TaskInfo taskInfo = {}; - TaskInfo *task = &taskInfo; + TaskInfo* task = &taskInfo; captureModel.context_ = stream->Context_(); InitByStream(task, stream_); @@ -1248,15 +1220,13 @@ TEST_F(DavidStreamTest, Destructor_ArgHandleNonNull) rtStream_t streamHandle = 0; rtError_t res = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(res, RT_ERROR_NONE); - DavidStream *davidStream = (DavidStream *)(rt_ut::UnwrapOrNull(streamHandle)); + DavidStream* davidStream = (DavidStream*)(rt_ut::UnwrapOrNull(streamHandle)); ASSERT_NE(davidStream, nullptr); ASSERT_NE(davidStream->ArgManagePtr(), nullptr); - davidStream->SetArgHandle(reinterpret_cast(0x1U)); + davidStream->SetArgHandle(reinterpret_cast(0x1U)); - MOCKER_CPP_VIRTUAL(device_->ArgLoader_(), &ArgLoader::Release) - .expects(once()) - .will(returnValue(RT_ERROR_NONE)); + MOCKER_CPP_VIRTUAL(device_->ArgLoader_(), &ArgLoader::Release).expects(once()).will(returnValue(RT_ERROR_NONE)); res = rtStreamDestroy(streamHandle); EXPECT_EQ(res, RT_ERROR_NONE); @@ -1268,14 +1238,13 @@ TEST_F(DavidStreamTest, Destructor_ArgHandleNull) rtStream_t streamHandle = 0; rtError_t res = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(res, RT_ERROR_NONE); - DavidStream *davidStream = (DavidStream *)(rt_ut::UnwrapOrNull(streamHandle)); + DavidStream* davidStream = (DavidStream*)(rt_ut::UnwrapOrNull(streamHandle)); ASSERT_NE(davidStream, nullptr); ASSERT_NE(davidStream->ArgManagePtr(), nullptr); davidStream->SetArgHandle(nullptr); - MOCKER_CPP_VIRTUAL(device_->ArgLoader_(), &ArgLoader::Release) - .expects(never()); + MOCKER_CPP_VIRTUAL(device_->ArgLoader_(), &ArgLoader::Release).expects(never()); res = rtStreamDestroy(streamHandle); EXPECT_EQ(res, RT_ERROR_NONE); @@ -1284,55 +1253,55 @@ TEST_F(DavidStreamTest, Destructor_ArgHandleNull) TEST_F(DavidStreamTest, SetAicoreArgsSuperKernel_HandleNull) { - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); TaskInfo taskInfo = {0}; taskInfo.stream = stream; - + rtArgsEx_t argsInfo = {0}; argsInfo.argsSize = 512; - + StarsArgLoaderResult result = {0}; result.kerArgs = reinterpret_cast(0x11111111); result.handle = nullptr; - + SetAicoreArgsSuperKernel(&taskInfo, &argsInfo, result); - + EXPECT_EQ(taskInfo.u.aicTaskInfo.comm.argsSize, 512U); EXPECT_EQ(taskInfo.u.aicTaskInfo.comm.args, reinterpret_cast(0x11111111)); EXPECT_EQ(taskInfo.u.aicTaskInfo.comm.argHandle, nullptr); EXPECT_FALSE(taskInfo.needPostProc); EXPECT_EQ(result.handle, nullptr); - + delete stream; } TEST_F(DavidStreamTest, BackupTaskArgHandle_ArgHandleNull) { - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); TaskInfo taskInfo = {0}; taskInfo.stream = stream; taskInfo.u.aicTaskInfo.comm.argHandle = nullptr; - + BackupTaskArgHandle(&taskInfo); - + EXPECT_EQ(stream->argHandleRecycleList_.size(), 0U); EXPECT_EQ(taskInfo.u.aicTaskInfo.comm.argHandle, nullptr); - + delete stream; } TEST_F(DavidStreamTest, BackupTaskArgHandle_Normal) { - DavidStream *stream = new DavidStream(device_, 0, 0, nullptr); + DavidStream* stream = new DavidStream(device_, 0, 0, nullptr); TaskInfo taskInfo = {0}; taskInfo.stream = stream; taskInfo.u.aicTaskInfo.comm.argHandle = reinterpret_cast(0x12345678); - + BackupTaskArgHandle(&taskInfo); - + EXPECT_EQ(stream->argHandleRecycleList_.size(), 1U); EXPECT_EQ(stream->argHandleRecycleList_[0], reinterpret_cast(0x12345678)); EXPECT_EQ(taskInfo.u.aicTaskInfo.comm.argHandle, nullptr); - + delete stream; } diff --git a/tests/ut/runtime/runtime/test/platform/950/rt_utest_david_task_recycle.cc b/tests/ut/runtime/runtime/test/platform/950/rt_utest_david_task_recycle.cc index 2a0d57d..74d69c2 100644 --- a/tests/ut/runtime/runtime/test/platform/950/rt_utest_david_task_recycle.cc +++ b/tests/ut/runtime/runtime/test/platform/950/rt_utest_david_task_recycle.cc @@ -47,14 +47,14 @@ namespace { constexpr uint32_t TS_CCU_STATUS_DDRC_ERROR = 0x02; constexpr uint32_t TS_CCU_STATUS_POISON_ERROR = 0x03; constexpr uint32_t TS_CCU_STATUS_DDRC_ERROR_SUBSTATUS = 0x0; -} +} // namespace static bool g_disableThread; static rtChipType_t g_chipType; extern int64_t g_device_driver_version_stub; -static drvError_t stubDavidGetDeviceInfo(uint32_t devId, int32_t moduleType, int32_t infoType, int64_t *value) +static drvError_t stubDavidGetDeviceInfo(uint32_t devId, int32_t moduleType, int32_t infoType, int64_t* value) { if (value) { if (moduleType == MODULE_TYPE_SYSTEM && infoType == INFO_TYPE_VERSION) { @@ -74,12 +74,12 @@ protected: { // backup oringal attribute of runtime MOCKER(halGetDeviceInfo).stubs().will(invoke(stubDavidGetDeviceInfo)); - char *socVer = "Ascend950PR_9599"; + char* socVer = "Ascend950PR_9599"; MOCKER(halGetSocVersion) .stubs() .with(mockcpp::any(), outBoundP(socVer, strlen("Ascend950PR_9599")), mockcpp::any()) .will(returnValue(DRV_ERROR_NONE)); - Runtime *rtInstance = (Runtime *)Runtime::Instance(); + Runtime* rtInstance = (Runtime*)Runtime::Instance(); g_disableThread = rtInstance->GetDisableThread(); g_chipType = rtInstance->GetChipType(); rtInstance->SetDisableThread(true); @@ -90,7 +90,7 @@ protected: static void TearDownTestCase() { // restore oringal attribute - Runtime *rtInstance = (Runtime *)Runtime::Instance(); + Runtime* rtInstance = (Runtime*)Runtime::Instance(); rtInstance->SetDisableThread(g_disableThread); rtInstance->SetChipType(g_chipType); GlobalContainer::SetRtChipType(g_chipType); @@ -99,12 +99,12 @@ protected: virtual void SetUp() { std::cout << "TaskResManageTest SetUp start" << std::endl; - Driver *driver_ = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); - MOCKER_CPP_VIRTUAL((NpuDriver *)(driver_), &NpuDriver::GetRunMode) + Driver* driver_ = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + MOCKER_CPP_VIRTUAL((NpuDriver*)(driver_), &NpuDriver::GetRunMode) .stubs() .will(returnValue((uint32_t)RT_RUN_MODE_ONLINE)); MOCKER(halGetDeviceInfo).stubs().will(invoke(stubDavidGetDeviceInfo)); - char *socVer = "Ascend950PR_9599"; + char* socVer = "Ascend950PR_9599"; MOCKER(halGetSocVersion) .stubs() .with(mockcpp::any(), outBoundP(socVer, strlen("Ascend950PR_9599")), mockcpp::any()) @@ -125,19 +125,17 @@ protected: TEST_F(DavidTaskRecycleTest, TestTaskRes) { - TaskResManageDavid *taskResMng = new (std::nothrow) TaskResManageDavid; + TaskResManageDavid* taskResMng = new (std::nothrow) TaskResManageDavid; taskResMng->taskPoolNum_ = 2049; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; - MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) - .stubs() - .will(returnValue(RT_ERROR_NONE)); + void* addr = &support; + MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc).stubs().will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); rtStream_t stream = nullptr; @@ -147,7 +145,7 @@ TEST_F(DavidTaskRecycleTest, TestTaskRes) EXPECT_EQ(ret, true); uint32_t pos = UINT32_MAX; - TaskInfo *task = nullptr; + TaskInfo* task = nullptr; error = taskResMng->AllocTaskInfoAndPos(3U, pos, &task); EXPECT_EQ(error, RT_ERROR_NONE); EXPECT_EQ(pos, 0); @@ -163,7 +161,7 @@ TEST_F(DavidTaskRecycleTest, TestTaskRes) taskResMng->GetHeadTail(head, tail); EXPECT_EQ(head, 0); EXPECT_EQ(tail, 67); - TaskInfo *getTask = taskResMng->GetTaskInfo(10); + TaskInfo* getTask = taskResMng->GetTaskInfo(10); EXPECT_NE(getTask, nullptr); getTask = taskResMng->GetTaskInfo(66); EXPECT_NE(getTask, nullptr); @@ -258,23 +256,25 @@ TEST_F(DavidTaskRecycleTest, TestTaskRes) taskResMng->ReleaseTaskResource(rt_ut::UnwrapOrNull(stream)); rtStreamDestroy(stream); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); delete taskResMng; } TEST_F(DavidTaskRecycleTest, SyncTaskRecycleBySqHead) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); @@ -284,8 +284,8 @@ TEST_F(DavidTaskRecycleTest, SyncTaskRecycleBySqHead) rt_ut::UnwrapOrNull(stream)->SetSqMemAttr(false); uint32_t pos = UINT32_MAX; - TaskInfo *task = nullptr; - TaskResManageDavid *taskResMang = ((TaskResManageDavid *)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); + TaskInfo* task = nullptr; + TaskResManageDavid* taskResMang = ((TaskResManageDavid*)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); for (uint32_t i = 0; i < 1; i++) { error = taskResMang->AllocTaskInfoAndPos(1U, pos, &task); @@ -298,8 +298,8 @@ TEST_F(DavidTaskRecycleTest, SyncTaskRecycleBySqHead) } uint16_t sqHead = 1; - Driver *driver; - driver = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + Driver* driver; + driver = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); MOCKER_CPP_VIRTUAL(driver, &Driver::GetSqHead) .stubs() .with(mockcpp::any(), mockcpp::any(), mockcpp::any(), outBound(sqHead)) @@ -311,22 +311,24 @@ TEST_F(DavidTaskRecycleTest, SyncTaskRecycleBySqHead) EXPECT_EQ(error, RT_ERROR_NONE); rtStreamDestroy(stream); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, SyncTaskRecycleBySqHeadV2) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); @@ -336,8 +338,8 @@ TEST_F(DavidTaskRecycleTest, SyncTaskRecycleBySqHeadV2) rt_ut::UnwrapOrNull(stream)->SetSqMemAttr(false); uint32_t pos = UINT32_MAX; - TaskInfo *task = nullptr; - TaskResManageDavid *taskResMang = ((TaskResManageDavid *)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); + TaskInfo* task = nullptr; + TaskResManageDavid* taskResMang = ((TaskResManageDavid*)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); for (uint32_t i = 0; i < 1; i++) { error = taskResMang->AllocTaskInfoAndPos(1U, pos, &task); @@ -350,8 +352,8 @@ TEST_F(DavidTaskRecycleTest, SyncTaskRecycleBySqHeadV2) } uint16_t sqHead = 1; - Driver *driver; - driver = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + Driver* driver; + driver = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); MOCKER_CPP_VIRTUAL(driver, &Driver::GetSqHead) .stubs() .with(mockcpp::any(), mockcpp::any(), mockcpp::any(), outBound(sqHead)) @@ -363,22 +365,19 @@ TEST_F(DavidTaskRecycleTest, SyncTaskRecycleBySqHeadV2) EXPECT_EQ(error, RT_ERROR_NONE); rtStreamDestroy(stream); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } rtLogicCqReport_t g_cqReport; -rtError_t Sub_LogicCqReportV2(NpuDriver *drv, const LogicCqWaitInfo &waitInfo, uint8_t *report, uint32_t reportCnt, - uint32_t &realCnt) +rtError_t Sub_LogicCqReportV2( + NpuDriver* drv, const LogicCqWaitInfo& waitInfo, uint8_t* report, uint32_t reportCnt, uint32_t& realCnt) { realCnt = 1; - rtLogicCqReport_t *reportPtr = reinterpret_cast(report); + rtLogicCqReport_t* reportPtr = reinterpret_cast(report); *reportPtr = g_cqReport; return RT_ERROR_NONE; } -void DvppGrpCallbackFunc(rtDvppGrpRptInfo_t *report) -{ - UNUSED(report); -} +void DvppGrpCallbackFunc(rtDvppGrpRptInfo_t* report) { UNUSED(report); } TEST_F(DavidTaskRecycleTest, DvppWaitGroup) { @@ -391,12 +390,12 @@ TEST_F(DavidTaskRecycleTest, DvppWaitGroup) ret = rtStreamCreateByGrp(&stream, 0, 0, grp); EXPECT_EQ(ret, ACL_RT_SUCCESS); - ((DvppGrp *)grp)->getContext()->Device_()->GetStreamSqCqManage()->sqIdToStreamIdMap_[0] = + ((DvppGrp*)grp)->getContext()->Device_()->GetStreamSqCqManage()->sqIdToStreamIdMap_[0] = rt_ut::UnwrapOrNull(stream)->Id_(); rt_ut::UnwrapOrNull(stream)->SetSqMemAttr(false); - Driver *driver; - driver = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); - MOCKER_CPP_VIRTUAL((NpuDriver *)(driver), &NpuDriver::LogicCqReportV2).stubs().will(invoke(Sub_LogicCqReportV2)); + Driver* driver; + driver = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + MOCKER_CPP_VIRTUAL((NpuDriver*)(driver), &NpuDriver::LogicCqReportV2).stubs().will(invoke(Sub_LogicCqReportV2)); ret = rtDvppWaitGroupReport(grp, DvppGrpCallbackFunc, 0); EXPECT_EQ(ret, ACL_RT_SUCCESS); @@ -419,12 +418,12 @@ TEST_F(DavidTaskRecycleTest, DvppWaitGroupCommonTaskReportLogicCq) ret = rtStreamCreateByGrp(&stream, 0, 0, grp); EXPECT_EQ(ret, ACL_RT_SUCCESS); rt_ut::UnwrapOrNull(stream)->SetSqMemAttr(false); - ((DvppGrp *)grp)->getContext()->Device_()->GetStreamSqCqManage()->sqIdToStreamIdMap_[0] = + ((DvppGrp*)grp)->getContext()->Device_()->GetStreamSqCqManage()->sqIdToStreamIdMap_[0] = rt_ut::UnwrapOrNull(stream)->Id_(); uint32_t pos = UINT32_MAX; - TaskInfo *task = nullptr; - TaskResManageDavid *taskResMang = ((TaskResManageDavid *)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); + TaskInfo* task = nullptr; + TaskResManageDavid* taskResMang = ((TaskResManageDavid*)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); for (uint32_t i = 0; i < 1; i++) { ret = taskResMang->AllocTaskInfoAndPos(1U, pos, &task); @@ -441,9 +440,9 @@ TEST_F(DavidTaskRecycleTest, DvppWaitGroupCommonTaskReportLogicCq) g_cqReport.streamId = rt_ut::UnwrapOrNull(stream)->Id_(); g_cqReport.taskId = pos; - Driver *driver; - driver = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); - MOCKER_CPP_VIRTUAL((NpuDriver *)(driver), &NpuDriver::LogicCqReportV2).stubs().will(invoke(Sub_LogicCqReportV2)); + Driver* driver; + driver = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + MOCKER_CPP_VIRTUAL((NpuDriver*)(driver), &NpuDriver::LogicCqReportV2).stubs().will(invoke(Sub_LogicCqReportV2)); ret = rtDvppWaitGroupReport(grp, DvppGrpCallbackFunc, 0); EXPECT_EQ(ret, ACL_RT_SUCCESS); @@ -468,12 +467,12 @@ TEST_F(DavidTaskRecycleTest, DvppWaitGroupCommonTaskReportLogicCqVPC) EXPECT_EQ(ret, ACL_RT_SUCCESS); rt_ut::UnwrapOrNull(stream)->SetSqMemAttr(false); - ((DvppGrp *)grp)->getContext()->Device_()->GetStreamSqCqManage()->sqIdToStreamIdMap_[0] = + ((DvppGrp*)grp)->getContext()->Device_()->GetStreamSqCqManage()->sqIdToStreamIdMap_[0] = rt_ut::UnwrapOrNull(stream)->Id_(); uint32_t pos = UINT32_MAX; - TaskInfo *task = nullptr; - TaskResManageDavid *taskResMang = ((TaskResManageDavid *)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); + TaskInfo* task = nullptr; + TaskResManageDavid* taskResMang = ((TaskResManageDavid*)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); for (uint32_t i = 0; i < 1; i++) { ret = taskResMang->AllocTaskInfoAndPos(1U, pos, &task); @@ -490,9 +489,9 @@ TEST_F(DavidTaskRecycleTest, DvppWaitGroupCommonTaskReportLogicCqVPC) g_cqReport.taskId = pos; g_cqReport.errorType = RT_STARS_CQE_ERR_TYPE_EXCEPTION; g_cqReport.sqeType = RT_STARS_SQE_TYPE_VPC; - Driver *driver; - driver = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); - MOCKER_CPP_VIRTUAL((NpuDriver *)(driver), &NpuDriver::LogicCqReportV2).stubs().will(invoke(Sub_LogicCqReportV2)); + Driver* driver; + driver = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + MOCKER_CPP_VIRTUAL((NpuDriver*)(driver), &NpuDriver::LogicCqReportV2).stubs().will(invoke(Sub_LogicCqReportV2)); bool enable = false; MOCKER_CPP_VIRTUAL(driver, &Driver::GetSqEnable) @@ -515,17 +514,19 @@ TEST_F(DavidTaskRecycleTest, DvppWaitGroupCommonTaskReportLogicCqVPC) TEST_F(DavidTaskRecycleTest, ProcLogicCqReport) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); @@ -545,22 +546,24 @@ TEST_F(DavidTaskRecycleTest, ProcLogicCqReport) GlobalMockObject::verify(); error = rtStreamDestroy(stream); EXPECT_EQ(error, ACL_RT_SUCCESS); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, TryRecycleTaskV2) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); @@ -571,8 +574,8 @@ TEST_F(DavidTaskRecycleTest, TryRecycleTaskV2) rt_ut::UnwrapOrNull(stream)->SetRecycleFlag(true); rt_ut::UnwrapOrNull(stream)->SetNeedRecvCqeFlag(true); - Driver *driver; - driver = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + Driver* driver; + driver = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); MOCKER_CPP_VIRTUAL(driver, &Driver::LogicCqReportV2) .stubs() .will(returnValue(RT_ERROR_NONE)) @@ -588,36 +591,38 @@ TEST_F(DavidTaskRecycleTest, TryRecycleTaskV2) error = rtStreamDestroy(stream); EXPECT_EQ(error, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, TryRecycleTaskAbort) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); rtStream_t stream = nullptr; rtError_t error = rtStreamCreate(&stream, 0); EXPECT_EQ(error, RT_ERROR_NONE); - Stream *streamObj = rt_ut::UnwrapOrNull(stream); + Stream* streamObj = rt_ut::UnwrapOrNull(stream); streamObj->SetSqMemAttr(false); streamObj->SetRecycleFlag(true); streamObj->SetNeedRecvCqeFlag(true); streamObj->Device_()->SetDeviceStatus(RT_ERROR_DEVICE_TASK_ABORT); streamObj->SetAbortStatus(RT_ERROR_STREAM_ABORT); - Driver *driver; - driver = ((Runtime *)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); + Driver* driver; + driver = ((Runtime*)Runtime::Instance())->driverFactory_.GetDriver(NPU_DRIVER); MOCKER_CPP_VIRTUAL(driver, &Driver::LogicCqReportV2) .stubs() .will(returnValue(RT_ERROR_NONE)) @@ -633,22 +638,24 @@ TEST_F(DavidTaskRecycleTest, TryRecycleTaskAbort) error = rtStreamDestroy(stream); EXPECT_EQ(error, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, TaskReclaimByStreamV2) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); @@ -656,7 +663,7 @@ TEST_F(DavidTaskRecycleTest, TaskReclaimByStreamV2) rtStream_t stream = nullptr; rtError_t error = rtStreamCreate(&stream, 0); EXPECT_EQ(error, RT_ERROR_NONE); - Stream *streamObj = rt_ut::UnwrapOrNull(stream); + Stream* streamObj = rt_ut::UnwrapOrNull(stream); streamObj->SetSqMemAttr(false); rt_ut::UnwrapOrNull(stream)->SetFailureMode(ABORT_ON_FAILURE); @@ -669,23 +676,25 @@ TEST_F(DavidTaskRecycleTest, TaskReclaimByStreamV2) EXPECT_EQ(error, RT_ERROR_NONE); error = rtStreamDestroy(stream); EXPECT_EQ(error, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, TryReclaimToTask) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - ((RawDevice *)device)->chipType_ = CHIP_DAVID; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + ((RawDevice*)device)->chipType_ = CHIP_DAVID; uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); @@ -702,11 +711,11 @@ TEST_F(DavidTaskRecycleTest, TryReclaimToTask) .stubs() .with(mockcpp::any(), mockcpp::any(), mockcpp::any(), outBoundP(&delPos)) .will(returnValue(RT_ERROR_NONE)); - //delWorkTask == nullptr abnormal + // delWorkTask == nullptr abnormal TryReclaimToTask(&taskInfo); // check cqe - TaskResManageDavid *taskResMang = ((TaskResManageDavid *)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); + TaskResManageDavid* taskResMang = ((TaskResManageDavid*)(rt_ut::UnwrapOrNull(stream)->taskResMang_)); taskResMang->taskResATail_.Set(1); taskResMang->taskRes_[0].taskInfo.id = 0; taskResMang->taskRes_[0].taskInfo.isCqeNeedConcern = true; @@ -723,22 +732,24 @@ TEST_F(DavidTaskRecycleTest, TryReclaimToTask) taskResMang->taskResATail_.Set(0); error = rtStreamDestroy(stream); EXPECT_EQ(error, ACL_RT_SUCCESS); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, FinishedTaskReclaim) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); @@ -756,25 +767,25 @@ TEST_F(DavidTaskRecycleTest, FinishedTaskReclaim) error = rtStreamDestroy(stream); EXPECT_EQ(error, ACL_RT_SUCCESS); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, ProcReport) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - TaskInfo *reportTask = nullptr; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + TaskInfo* reportTask = nullptr; MOCKER(GetTaskInfo).stubs().will(returnValue(reportTask)); rtLogicCqReport_t report = {0}; bool isFinished = false; bool hasCqeReportErr = false; uint32_t pos = ProcReport(device, 0U, 65535, 1, &report, isFinished, hasCqeReportErr); EXPECT_EQ(pos, 0); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, ProcReportWithTaskMultiple) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); TaskInfo reportTask = {}; reportTask.type = TS_TASK_TYPE_MULTIPLE_TASK; MOCKER(GetSendDavidSqeNum).stubs().will(returnValue(2)); @@ -792,12 +803,12 @@ TEST_F(DavidTaskRecycleTest, ProcReportWithTaskMultiple) pos = ProcReport(device, 0U, 65535, 1, &report, isFinished, hasCqeReportErr); EXPECT_EQ(pos, 0); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, ProcCqReportException) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); TaskInfo reportTask = {}; rtLogicCqReport_t report = {0}; report.sqeType = TS_TASK_TYPE_KERNEL_AICORE; @@ -816,13 +827,13 @@ TEST_F(DavidTaskRecycleTest, ProcCqReportException) report.errorCode = 0x60004; ProcCqReportException(device, report, &reportTask, 0U); EXPECT_EQ(reportTask.type, 0); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, ProcCqReportException_Abnormal) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - ((Runtime *)Runtime::Instance())->SetRuntimeExiting(true); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + ((Runtime*)Runtime::Instance())->SetRuntimeExiting(true); TaskInfo reportTask = {}; rtLogicCqReport_t report = {0}; report.sqeType = TS_TASK_TYPE_KERNEL_AICORE; @@ -830,15 +841,15 @@ TEST_F(DavidTaskRecycleTest, ProcCqReportException_Abnormal) report.errorCode = TS_ERROR_AICORE_OVERFLOW; ProcCqReportException(device, report, &reportTask, 0U); - ((Runtime *)Runtime::Instance())->SetRuntimeExiting(false); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->SetRuntimeExiting(false); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, StarsResumeRtsq_01) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); @@ -863,14 +874,14 @@ TEST_F(DavidTaskRecycleTest, StarsResumeRtsq_01) EXPECT_EQ(ret, RT_ERROR_NONE); ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, StarsResumeRtsq_02) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); @@ -896,17 +907,17 @@ TEST_F(DavidTaskRecycleTest, StarsResumeRtsq_02) EXPECT_EQ(ret, RT_ERROR_STREAM_ABORT); ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, DoCompleteSuccessForNotifyWaitTask) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Model *model; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Model* model; rtModel_t modelHandle = nullptr; - Stream *stream; - Notify *notify; + Stream* stream; + Notify* notify; rtStream_t streamHandle = nullptr; rtNotify_t notifyHandle = nullptr; @@ -937,18 +948,18 @@ TEST_F(DavidTaskRecycleTest, DoCompleteSuccessForNotifyWaitTask) EXPECT_EQ(ret, RT_ERROR_NONE); ret = rtModelDestroy(modelHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } extern int32_t faultEventFlag; TEST_F(DavidTaskRecycleTest, DoCompleteSuccessForNotifyWaitTaskForAiCpu) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); - Model *model = nullptr; - Stream *stream = nullptr; - Notify *notify = nullptr; + Model* model = nullptr; + Stream* stream = nullptr; + Notify* notify = nullptr; rtStream_t streamHandle = nullptr; rtNotify_t notifyHandle = nullptr; rtModel_t modelHandle = nullptr; @@ -989,16 +1000,16 @@ TEST_F(DavidTaskRecycleTest, DoCompleteSuccessForNotifyWaitTaskForAiCpu) ret = rtModelDestroy(modelHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, PrintErrorInfo) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Model *model; - Stream *stream; - Notify *notify; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Model* model; + Stream* stream; + Notify* notify; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); @@ -1020,14 +1031,14 @@ TEST_F(DavidTaskRecycleTest, PrintErrorInfo) ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, CCUTask) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); @@ -1047,15 +1058,15 @@ TEST_F(DavidTaskRecycleTest, CCUTask) ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } extern int32_t faultEventFlag; TEST_F(DavidTaskRecycleTest, CCUTaskHBMError) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); @@ -1086,14 +1097,14 @@ TEST_F(DavidTaskRecycleTest, CCUTaskHBMError) ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, FusionTaskAbort) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); @@ -1113,14 +1124,14 @@ TEST_F(DavidTaskRecycleTest, FusionTaskAbort) ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, DoCompleteSuccessForMemcpyAsyncTask) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); @@ -1136,19 +1147,19 @@ TEST_F(DavidTaskRecycleTest, DoCompleteSuccessForMemcpyAsyncTask) ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, DoCompleteSuccessForMemcpyAsyncTaskForSDMALinkError) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); stream = rt_ut::UnwrapOrNull(streamHandle); - + MOCKER(PrintErrorInfoForMemcpyAsyncTask).stubs(); TaskInfo taskInfo = {0}; @@ -1160,62 +1171,58 @@ TEST_F(DavidTaskRecycleTest, DoCompleteSuccessForMemcpyAsyncTaskForSDMALinkError ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, PrintAsyncPtrProcFunction) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); stream = rt_ut::UnwrapOrNull(streamHandle); - Driver *driver = device->Driver_(); + Driver* driver = device->Driver_(); ASSERT_NE(driver, nullptr); char_t errMsg[MSG_LENGTH] = {}; - char_t *errStr = errMsg; + char_t* errStr = errMsg; int32_t countNum = 0; rtDavidMemcpyAddrInfo deviceAddrInfo = {}; - MOCKER_CPP_VIRTUAL(driver, &Driver::MemCopySync) - .stubs() - .will(returnValue(RT_ERROR_NONE)); + MOCKER_CPP_VIRTUAL(driver, &Driver::MemCopySync).stubs().will(returnValue(RT_ERROR_NONE)); MOCKER(PrintModuleIdProc).stubs(); - PrintAsyncPtrProc(driver, errStr, static_cast(&deviceAddrInfo), countNum); + PrintAsyncPtrProc(driver, errStr, static_cast(&deviceAddrInfo), countNum); GlobalMockObject::verify(); ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, PrintAsyncPtrProcErrorCheck) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); stream = rt_ut::UnwrapOrNull(streamHandle); - Driver *driver = device->Driver_(); + Driver* driver = device->Driver_(); ASSERT_NE(driver, nullptr); char_t errMsg[MSG_LENGTH] = {}; - char_t *errStr = errMsg; + char_t* errStr = errMsg; int32_t countNum = 0; rtDavidMemcpyAddrInfo deviceAddrInfo = {}; - MOCKER_CPP_VIRTUAL(driver, &Driver::MemCopySync) - .stubs() - .will(returnValue(RT_ERROR_DRV_ERR)); + MOCKER_CPP_VIRTUAL(driver, &Driver::MemCopySync).stubs().will(returnValue(RT_ERROR_DRV_ERR)); - PrintAsyncPtrProc(driver, errStr, static_cast(&deviceAddrInfo), countNum); + PrintAsyncPtrProc(driver, errStr, static_cast(&deviceAddrInfo), countNum); EXPECT_TRUE(countNum == 0 || strstr(errStr, "src_addr=") == nullptr); GlobalMockObject::verify(); @@ -1223,9 +1230,7 @@ TEST_F(DavidTaskRecycleTest, PrintAsyncPtrProcErrorCheck) countNum = 0; (void)memset_s(errMsg, MSG_LENGTH, 0, MSG_LENGTH); - MOCKER_CPP_VIRTUAL(driver, &Driver::MemCopySync) - .stubs() - .will(returnValue(RT_ERROR_INVALID_VALUE)); + MOCKER_CPP_VIRTUAL(driver, &Driver::MemCopySync).stubs().will(returnValue(RT_ERROR_INVALID_VALUE)); PrintAsyncPtrProc(driver, errStr, nullptr, countNum); @@ -1234,14 +1239,14 @@ TEST_F(DavidTaskRecycleTest, PrintAsyncPtrProcErrorCheck) ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, PrintErrorInfoForStreamLabelSwitchByIndexTask) { rtError_t ret; - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); - Stream *stream; + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); + Stream* stream; rtStream_t streamHandle = nullptr; ret = rtStreamCreate(&streamHandle, 0); EXPECT_EQ(ret, RT_ERROR_NONE); @@ -1258,29 +1263,31 @@ TEST_F(DavidTaskRecycleTest, PrintErrorInfoForStreamLabelSwitchByIndexTask) ret = rtStreamDestroy(streamHandle); EXPECT_EQ(ret, RT_ERROR_NONE); - ((Runtime *)Runtime::Instance())->DeviceRelease(device); + ((Runtime*)Runtime::Instance())->DeviceRelease(device); } TEST_F(DavidTaskRecycleTest, RecycleModeLabel) { - Device *device = ((Runtime *)Runtime::Instance())->DeviceRetain(0, 0); + Device* device = ((Runtime*)Runtime::Instance())->DeviceRetain(0, 0); uint32_t support = RT_CAPABILITY_SUPPORT; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::CheckSupportPcieBarCopy) .stubs() .with(mockcpp::any(), outBound(support), mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); - void *addr = &support; + void* addr = &support; MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::DevMemAlloc) .stubs() - .with(outBoundP(&addr, sizeof(void *)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any()) + .with( + outBoundP(&addr, sizeof(void*)), mockcpp::any(), mockcpp::any(), mockcpp::any(), mockcpp::any(), + mockcpp::any()) .will(returnValue(RT_ERROR_NONE)); MOCKER_CPP_VIRTUAL(device->Driver_(), &Driver::PcieHostRegister).stubs().will(returnValue(RT_ERROR_NONE)); rtStream_t stream = nullptr; rtError_t error = rtStreamCreate(&stream, 0); EXPECT_EQ(error, RT_ERROR_NONE); - Stream *streamObj = rt_ut::UnwrapOrNull(stream); + Stream* streamObj = rt_ut::UnwrapOrNull(stream); streamObj->SetSqMemAttr(false); rtModel_t model; rtLabel_t label; @@ -1290,16 +1297,16 @@ TEST_F(DavidTaskRecycleTest, RecycleModeLabel) EXPECT_EQ(error, RT_ERROR_NONE); uint32_t val = 0x123; - Model *realModel = rt_ut::UnwrapOrNull(model); - Label *realLabel = rt_ut::UnwrapOrNull