ACL Graph：流捕获到底捕获了什么

// feature/aclgraph/stream_capture.cc:294
rtError_t StreamCapture::AllocTask(Stream* stm, tsTaskType_t taskType, uint32_t sqeNum, TaskInfo** task)
{
    std::unique_lock<std::mutex> lock(stm->GetCaptureLock());
    Stream* curCaptureStream = stm->GetCaptureStream();
    if (curCaptureStream == nullptr) {
        return RT_ERROR_STREAM_CAPTURE_EXIT;
    }
    // ... 级联流处理 ...
    if (curCaptureStream->taskResMang_ == nullptr) {
        rtError_t errCode = RT_ERROR_TASK_NEW;
        *task = stm->Device_()->GetTaskFactory()->Alloc(curCaptureStream, taskType, errCode);
        if (*task == nullptr) {
            Terminate(stm);
            return errCode;
        }
        curCaptureStream->AddCaptureSqeNum(sqeNum);
        Runtime::Instance()->AllocTaskSn((*task)->taskSn);
        SaveTaskCommonInfo(*task, curCaptureStream, sqeNum);
        // ...
        return RT_ERROR_NONE;          // ← 到这里就返回了，没有 SubmitTask
    }
    const rtError_t ret = AllocCaptureTaskByTaskRes(curCaptureStream, sqeNum, task);
    // ...
}

// core/src/stream/stream.cc:4966
TaskInfo* Stream::AllocCaptureTask(tsTaskType_t taskType, uint32_t sqeNum, TaskInfo* pTask, rtError_t& errorReason)

// feature/aclgraph/capture_session.cc:1161
const CaptureFunc funcs = {
    .createContextExtension = &CreateCaptureSession,
    .createStreamExtension = &CreateStreamCapture,
    .createSubCaptureModels = &CreateSubCaptureModels,
    .detachCaptureEvent = &DetachCaptureEvent,
    .setTaskGroupErrCode = &SetTaskGroupErrCode,
    .allocCaptureTask = &StreamCapture::AllocTask,
    .generateSeqId = &GenerateSeqId,
    .getModelIfCapture = &GetModelIfCapture,
    .backupArgHandle = &BackupCaptureArgHandle,
    .isCaptureFinish = &IsCaptureFinish,
    .cacheCaptureTaskId = &CacheCaptureTaskId,
    .getCacheOpInfoSwitch = &GetStreamCacheOpInfoSwitch,
    .setCacheOpInfoOriginSwitch = &SetStreamCacheOpInfoOriginSwitch,
    .isOrigCaptureStream = &IsOriginalCaptureStream,
    .resetTaskGroup = &ResetStreamTaskGroup,
    .updateTask = &UpdateStreamTask,
    .packingTaskGroup = &PackStreamTaskGroup,
};
RegCaptureFunc(funcs);

// feature/aclgraph/capture_session.cc:1184
static bool g_captureFuncRegister = CaptureFuncRegister();

// Reduced builds only register stubs for callbacks reachable outside capture-specific state.
struct CaptureFunc {
    PfnCreateContextExtension createContextExtension;
    // ... 17 个函数指针
};

// feature/aclgraph/capture_session.hpp:30
class CaptureSession final : public ContextExtension {
    // ...
    Context* const ctx_;
    rtStreamCaptureMode captureMode_{RT_STREAM_CAPTURE_MODE_MAX};
    uint32_t captureModeRefNum_[RT_STREAM_CAPTURE_MODE_MAX] = {0U};
};

// feature/aclgraph/stream_capture.hpp:29
class StreamCapture final : public StreamExtension {
    // ...
    std::list<uint16_t> cacheCaptureTaskIds_;      // 捕获到的 task id，按顺序
    uint32_t cacheOpInfoOriginSwitch_{0U};
    uint32_t cacheOpInfoSwitch_{0U};
    bool isOrigCaptureStream_{false};              // 是不是 BeginCapture 那条流
    bool isLastLevelCaptureStream_{true};          // 级联链的末级
    Stream* parentCaptureStream_{nullptr};         // ← 链
    Stream* childCaptureStream_{nullptr};          // ← 链
    rtStreamCaptureMode captureMode_{RT_STREAM_CAPTURE_MODE_MAX};
    std::unique_ptr<TaskGroup> taskGroup_;         // 当前任务组
    std::mutex taskGroupMutex_;
    TaskGroup* updateTaskGroup_{nullptr};          // 正在更新的任务组
    bool isSubCaptureModel_{false};                // 是不是条件子图
    uint32_t beginCaptureThreadId_{UINT32_MAX};    // 谁开的捕获
};

// feature/aclgraph/stream_capture.cc:123-134
StreamCapture* StreamCapture::GetOrCreate(const Stream* stm)
{
    if (stm == nullptr) {
        return nullptr;
    }
    return dynamic_cast<StreamCapture*>(stm->EnsureExtension());
}

StreamCapture* StreamCapture::Get(const Stream* stm)
{
    return (stm == nullptr) ? nullptr : dynamic_cast<StreamCapture*>(stm->GetExtension());
}

// feature/aclgraph/capture_session.cc:713
rtError_t CaptureSession::StreamBeginCapture(Stream* const stm, const rtStreamCaptureMode mode, Model* const mdl)
{
    Model* captureModel = mdl;

    BufferAllocator::OpenHugeBuff();                     // ① 打开大页
    std::unique_lock<std::mutex> taskLock(ctx_->GetCaptureLock());

    rtError_t error = CheckCaptureModelIsCaptured(mdl);   // ② 模型已在捕获中？
    // ...
    const rtStreamCaptureStatus status = stm->GetCaptureStatus();
    COND_RETURN_AND_MSG_OUTER(
        status != RT_STREAM_CAPTURE_STATUS_NONE, RT_ERROR_STREAM_CAPTURED, ErrorCode::EE1016, "Stream begin capture",
        // ...

    if (captureModel == nullptr) {                        // ③ 建模型
        error = ctx_->ModelCreate(&captureModel, RT_MODEL_CAPTURE_MODEL);
        // ...
    }

    if ((stm->Device_()->IsSupportFeature(RtOptionalFeatureType::RT_FEATURE_MODEL_ACL_GRAPH_SOFTWARE_ENABLE)) &&
        (stm->Device_()->CheckFeatureSupport(TS_FEATURE_SOFTWARE_SQ_ENABLE)) &&
        (NpuDriver::CheckIsSupportFeature(ctx_->Device_()->Id(), FEATURE_TRSDRV_SQ_SUPPORT_DYNAMIC_BIND))) {
        CaptureModel* captureModelTmp = dynamic_cast<CaptureModel*>(captureModel);
        captureModelTmp->SetSoftwareSqEnable();            // ④ 三条件全中才开逻辑 SQ
    }

    error = StreamAddToCaptureModelProc(stm, captureModel, true);   // ⑤ 建捕获流
    // ...
    error = CaptureModeEnter(stm, mode);                  // ⑥ 登记模式
    // ...
}

设备支持该特性（RtOptionalFeatureType）
&& TS 报自己支持 SOFTWARE_SQ_ENABLE
&& 驱动报自己支持 SQ 动态绑定

// feature/aclgraph/capture_session.cc:60
bool CaptureSession::IsCaptureModeSupport(void) const
{
    const rtStreamCaptureMode contextCaptureMode = GetContextCaptureMode();
    /* no capture scene, support */
    if (contextCaptureMode == RT_STREAM_CAPTURE_MODE_MAX) {
        return true;
    }

    const rtStreamCaptureMode threadCaptureMode = InnerThreadLocalContainer::GetThreadCaptureMode();
    const rtStreamCaptureMode exchangeCaptureMode = InnerThreadLocalContainer::GetThreadExchangeCaptureMode();
    if (exchangeCaptureMode == RT_STREAM_CAPTURE_MODE_RELAXED) {
        return true;
    }

    if (exchangeCaptureMode == RT_STREAM_CAPTURE_MODE_GLOBAL) {
        if ((contextCaptureMode == RT_STREAM_CAPTURE_MODE_GLOBAL) ||
            (threadCaptureMode == RT_STREAM_CAPTURE_MODE_THREAD_LOCAL)) {
            return false;
        }
    }

    if (exchangeCaptureMode == RT_STREAM_CAPTURE_MODE_THREAD_LOCAL) {
        if ((threadCaptureMode == RT_STREAM_CAPTURE_MODE_GLOBAL) ||
            (threadCaptureMode == RT_STREAM_CAPTURE_MODE_THREAD_LOCAL)) {
            return false;
        }
    }
    return true;
}

// core/src/task/task_submit/v200/task_david.cc:287
bool NeedCascadeExpandStream(Stream* captureStm)
{
    if (captureStm->taskResMang_ != nullptr) {
        return (static_cast<uint32_t>(captureStm->taskResMang_->GetResTail()) + CAPTURE_TASK_RESERVED_NUM) >=
               captureStm->GetSqDepth();
    }
    return (captureStm->GetCaptureSqeNum() + CAPTURE_TASK_RESERVED_NUM +
            captureStm->Device_()->GetDevProperties().expandStreamRsvTaskNum) >= captureStm->GetSqDepth();
}

// core/src/launch/aix_stars.cc:376
/* 预留的CAPTURE_TASK_RESERVED_NUM(32)个SQE用于CaptureModel执行时申请的LoadComplete等SQE */

// feature/aclgraph/stream_capture.cc:274
void StreamCapture::UpdateCascadeStreamInfo(Stream* stm, Stream* newCaptureStream, Stream* curCaptureStream)
{
    StreamCapture* const currentCapture = Get(curCaptureStream);
    StreamCapture* const newCapture = Get(newCaptureStream);
    currentCapture->CancelLastLevelCaptureStream();          // 老的不再是末级
    newCapture->MarkOrigCaptureStream(currentCapture->IsOrigCaptureStream());  // 继承「原始流」身份
    std::unique_ptr<TaskGroup>& taskGroup = currentCapture->GetCurrentTaskGroup();
    newCapture->UpdateCurrentTaskGroup(taskGroup);           // 任务组跨级联传递！
    newCapture->SetParentCaptureStream(curCaptureStream);    // ← 建链
    currentCapture->SetChildCaptureStream(newCaptureStream);
    currentCapture->ResetTaskGroup();
    // ...
    stm->UpdateCaptureStream(newCaptureStream);              // 流改指向新捕获流
}

// feature/aclgraph/stream_capture.cc:319
error = CondStreamActive(newCaptureStream, curCaptureStream);

// core/src/launch/cond_starsv2.cc:55
rtError_t CondStreamActive(
    const Stream* const activeStream, Stream* const stm, Context* const ctx, const bool alreadyCascaded)
{
    // ...
    if ((strFlag & RT_STREAM_AICPU) != 0U) {
        return CondStreamActiveForAicpuStream(activeStream, stm);   // AICPU 流另一条路
    }
    // ...
    rtError_t error = CheckTaskCanSend(stm);
    // ...
}

// core/src/launch/cond_starsv2.cc:34-46
const void* const funcName = mdl->GetDevString(RT_DEV_STRING_ACTIVE_STREAM);
const uint32_t activeStreamId = static_cast<uint32_t>(activeStream->Id_());
// ...
(void)ActiveAicpuStreamTaskInit(
    tsk, RtPtrToValue<void*>(args), static_cast<uint32_t>(sizeof(int32_t)), RtPtrToValue<const void*>(funcName),
    TS_AICPU_KERNEL_CCE);

// feature/aclgraph/capture_session.cc:936
rtError_t CaptureSession::StreamEndCapture(Stream* const stm, Model** const captureMdl)
{
    // ... 状态检查、线程检查 ...
    CaptureModeExit(stm);

    // 条件子图都收尾了吗
    const bool isCaptureFinished = CheckSubModelsIsEndCapture(captureStream);
    COND_PROC_RETURN_AND_MSG_OUTER(
        !isCaptureFinished, RT_ERROR_STREAM_SUB_ACLGRAPH_IS_CAPTURING, ErrorCode::EE1016,
        // ...

    error = CheckCaptureModelValidity(captureModel);
    error = AddNotifyToAddedCaptureStream(stm, static_cast<CaptureModel*>(captureModelTmp));
    error = SetNotifyForExeModel(captureModelTmp);
    error = captureModelTmp->ResetCaptureEvents(stm);

    Api* const apiObj = Runtime::Instance()->ApiImpl_();
    captureStream = stm->GetCaptureStream();
    error = apiObj->ModelEndGraph(captureModel, captureStream, 0U);   // ← 这里发 EndGraph
    if ((error == RT_ERROR_DRV_NO_NOTIFY_RESOURCES) || (error == RT_ERROR_DRV_NO_RESOURCES)) {
        RT_LOG_OUTER_MSG_IMPL(
            ErrorCode::EE1023, "Alloc Notify resource", "Too many ACL graphs are executed concurrently");
    }
    UpdateEndGraphTaskSqeType(captureStream);                          // 改 SQE 类型

    error = captureModelTmp->EndCaptureAdapterProc();

    if (!captureModelTmp->IsSoftwareSqEnable()) {
        error = captureModel->LoadComplete();                          // 老路：装载完成
    } else if (Runtime::Instance()->GetConnectUbFlag()) {
        // ub + software sq enable
        for (Stream* innerStm : captureModelTmp->StreamList_()) {
            error = StreamJettyHandler::FillNopWqeOnCaptureEnd(innerStm, JettyType::JETTY_TYPE_H2D);
            error = StreamJettyHandler::FillNopWqeOnCaptureEnd(innerStm, JettyType::JETTY_TYPE_D2D_IN_BOARD);
            error = StreamJettyHandler::FillNopWqeOnCaptureEnd(innerStm, JettyType::JETTY_TYPE_D2D_CROSS_BOARD);
        }
    }

    (void)captureModel->ModelExecuteType();
    StreamCapture::ExitCapture(stm);
    *captureMdl = captureModel;
    // ...
}

// feature/aclgraph/capture_model.cc:1583
// 阶段一：Notify申请，发送endgraph挪到了endcapture阶段

JettyType::JETTY_TYPE_H2D
JettyType::JETTY_TYPE_D2D_IN_BOARD
JettyType::JETTY_TYPE_D2D_CROSS_BOARD

// core/inc/model/logic_sq.hpp:24
class LogicSq {
public:
    rtError_t SetUp(const uint32_t logicSqId, const uint32_t reserveSqeNum);
    rtError_t AllocDeviceSqeAddr(const uint32_t additionalSqeNum);
    bool GetStreamIdAndPosByHwPos(const uint32_t hwPos, uint32_t& streamId, uint32_t& pos) const;
    void SetHwPosMapping(const uint32_t hwPos, const uint32_t streamId, const uint32_t pos);
    // ...
private:
    Device* device_{nullptr};
    uint32_t id_{UINT32_MAX};
    uint16_t rtsqId_{UINT16_MAX};               // ← 执行时才填
    uint8_t* hostSqeAddr_{nullptr};             // ← host 侧 SQE 缓冲区
    uint32_t hostSqeSize_{0U};
    void* deviceSqeAddr_{nullptr};              // ← device 侧 SQE 地址
    uint32_t deviceSqeSize_{0U};
    uint32_t sqMemOrderType_{UINT32_MAX};       // 内存梯度
    uint32_t sqeNum_{0U};
    uint32_t logicSqDepth_{0U};
    uint32_t reserveSqeNum_{32U};
    uint64_t sqIdMemAddr_{0UL};                 // ← device 侧的 sqId 存放地址
    uint32_t streamId_{UINT32_MAX};
    uint32_t nextLogicSqId_{UINT32_MAX};        // ← 链成链表的下一段
    std::map<uint32_t, std::pair<uint32_t, uint32_t>> hwPosToTask_;  // key: hwPos, pair<streamId, pos>
    mutable std::mutex deviceSqeAddrMutex_;
};

// feature/aclgraph/logic_sq.cc:46
rtError_t LogicSq::SetUp(const uint32_t logicSqId, const uint32_t reserveSqeNum)
{
    id_ = logicSqId;
    logicSqDepth_ = STREAM_SQ_MAX_DEPTH;                 // 32768
    reserveSqeNum_ = reserveSqeNum;
    rtsqId_ = UINT16_MAX; // 推迟到模型执行时（BindSqCq）填充
    hostSqeSize_ = logicSqDepth_ * static_cast<uint32_t>(sizeof(rtStarsSqe_t));
    auto* hostBuf = new (std::nothrow) uint8_t[hostSqeSize_];
    // ...
    (void)memset_s(hostBuf, hostSqeSize_, 0U, hostSqeSize_);
    hostSqeAddr_ = hostBuf;
    return RT_ERROR_NONE;
}

// feature/aclgraph/logic_sq.cc:60
rtError_t LogicSq::AllocDeviceSqeAddr(const uint32_t additionalSqeNum)
{
    const std::lock_guard<std::mutex> lock(deviceSqeAddrMutex_);
    if (deviceSqeAddr_ != nullptr) {
        return RT_ERROR_NONE;
    }

    SqAddrMemoryOrder* sqAddrMemoryManage = device_->GetSqAddrMemoryManage();
    // ...
    const uint32_t allocSqeNum = GetSqeNum() + additionalSqeNum;
    const uint32_t allocMemSize = allocSqeNum * static_cast<uint32_t>(sizeof(rtStarsSqe_t));
    const uint32_t memOrderType = sqAddrMemoryManage->GetMemOrderTypeByMemSize(allocMemSize);
    const uint32_t memOrderSize = sqAddrMemoryManage->GetMemOrderSizeByMemOrderType(memOrderType);
    const uint32_t sqDepthAfterUpdate = memOrderSize / static_cast<uint32_t>(sizeof(rtStarsSqe_t));

    uint64_t* sqBaseAddr = nullptr;
    const rtError_t ret = sqAddrMemoryManage->AllocSqAddr(memOrderType, &sqBaseAddr);
    // ...
    deviceSqeAddr_ = RtPtrToPtr<void*>(sqBaseAddr);
    SetDeviceSqeSize(allocMemSize);
    SetSqMemOrderType(memOrderType);

    // stars v2要求sq深度必须是8的整数倍+1，调用者给additionalSqeNum加了8个，结合sq addr mem pool的各个内存梯度，
    // 可以保证这里再减7也能放的下全部的sqe，同时满足stars v2的要求。
    SetLogicSqDepth(sqDepthAfterUpdate - device_->GetDevProperties().expandStreamSqDepthAdapt);
    return RT_ERROR_NONE;
}

// core/inc/model/logic_sq.hpp:96
std::map<uint32_t, std::pair<uint32_t, uint32_t>> hwPosToTask_; // key: hwPos, pair<streamId, pos>

// feature/aclgraph/logic_sq.cc:98
bool LogicSq::GetStreamIdAndPosByHwPos(const uint32_t hwPos, uint32_t& streamId, uint32_t& pos) const
{
    const auto it = hwPosToTask_.find(hwPos);
    COND_RETURN_ERROR(
        it == hwPosToTask_.end(), false, "Get task failed, device_id=%u, logic_sq_id=%u, hw_pos=%u.", device_->Id_(),
        Id_(), hwPos);

    streamId = it->second.first;
    pos = it->second.second;
    return true;
}

// feature/aclgraph/capture_model.cc:1798
// rtsqId_ 已设置，绑定到 logicSqId（供 CQE 回收路径经 report.sqId 查 logicSq）
(void)mgr->BindRtsqToLogicSq(logicSq->GetRtsqId(), logicSq->Id_());

// core/inc/device/logic_sq_manage.hpp:39-40
std::map<uint32_t, uint32_t> rtsqIdToLogicSqIdMap_;      // 硬件 SQ → 逻辑 SQ
std::map<uint32_t, LogicSq*> logicSqIdToLogicSqMap_;     // 逻辑 SQ → 对象

// feature/aclgraph/capture_model.cc:531
rtError_t CaptureModel::PreModelExecute(
    Stream* const stm, ExternalEventRefreshInfo* refreshInfo, bool& executeRefAcquired)
{
    executeRefAcquired = false;
    rtError_t error = AddPreviousExecutionDependency(stm);      // ① 等上次执行完
    // ...
    error = SetNotifyBeforeExecute(stm, this);                  // ② 执行前同步
    // ...
    error = BuildSqCq(stm);                                     // ③ 建 SQ/CQ
    // ...
    executeRefAcquired = IsSoftwareSqEnable();

    error = InitAllSubCaptureModelCondTaskByDefValue(stm);      // ④ 条件值复位
    // ...
    error = PrepareGraphUpdateProc(stm);                        // ⑤ 图更新准备
    // ...
    error = PrepareExternalEventRefreshInfo(refreshInfo);       // ⑥ 外部事件刷新
    // ...
    error = SubmitExternalEventRefreshInfo(
        stm, refreshInfo, externalEventRefreshDeviceBase_, externalEventRefreshLayout_.totalSize, Id_());
    // ...
    CommitExternalEventRecords(refreshInfo);
    return RT_ERROR_NONE;
}

// feature/aclgraph/capture_model.cc:1550
rtError_t CaptureModel::BuildSqCq(Stream* const exeStream)
{
    COND_PROC(!IsSoftwareSqEnable(), return RT_ERROR_NONE);      // ← 非逻辑 SQ 模式直接跳过
    const std::unique_lock<std::mutex> lk(sqBindMutex_);

    SetRootExeStreamIdAll(static_cast<uint32_t>(exeStream->Id_()));
    rtError_t error = BindJettyForUbdma();                       // UB DMA 的 jetty 绑定
    // ...
    /* model execute repeat */
    COND_PROC_RETURN_WARN(
        (sqCqArray_ != nullptr) && (sqCqNum_ != 0U), RT_ERROR_NONE, refCount_++, "sqCqNum_=%u", sqCqNum_);
    //  ↑ 已经建过了：只加引用计数就返回

    const uint32_t streamNum = static_cast<uint32_t>(StreamList_().size());
    // ...
    uint32_t totalSqcqNum = 0;
    const uint32_t sqcqPoolResNum = Context_()->Device_()->GetDeviceSqCqManage()->GetSqCqPoolTotalResNum();
    GetSqCqTotalNum(totalSqcqNum);
    COND_PROC_RETURN_AND_MSG_OUTER(
        (totalSqcqNum > RT_DEVICE_SQCQ_RES_MAX_NUM), RT_ERROR_DRV_NO_RESOURCES, ErrorCode::EE1023,
        // ...

    // 阶段一：Notify申请，发送endgraph挪到了endcapture阶段
    // 阶段二：SqCq申请
    error = AllocAllSqCq();
    // ...
    // 阶段三：LoadComplete 刷notify record与子model notify wait sqe
    error = UpdateNotifyIdAll(exeStream);
    // ...
    error = LoadCompleteAll(loadCompleteNotifyId_);
    // ...
    UpdateIsNeedUpdateEndGraphFlagAll();
    error = UpdateStreamActiveTaskFuncCallMemAll();              // 阶段四
    // ...
    error = UpdateCondTaskFuncCallMemAll();                      // 阶段五
    // ...
    refCount_++;
    return RT_ERROR_NONE;
}

COND_PROC_RETURN_WARN((sqCqArray_ != nullptr) && (sqCqNum_ != 0U), RT_ERROR_NONE, refCount_++, ...);

// feature/aclgraph/capture_model.cc:1755
rtError_t CaptureModel::BindSqCq(void)
{
    rtError_t error = RT_ERROR_NONE;
    uint32_t index = 0U;
    const uint32_t logicSqNum = static_cast<uint32_t>(logicSqs_.size());
    Device* const dev = Context_()->Device_();

    COND_RETURN_ERROR_MSG_INNER(
        (sqCqNum_ != logicSqNum), RT_ERROR_INVALID_VALUE,
        "SQ/CQ numbers must be equal to logic sq numbers, sq num=%u, logic sq num=%u.", sqCqNum_, logicSqNum);
    // ...
    /* bind sq to logic sq */
    for (LogicSq* logicSq : logicSqs_) {
        // ...
        Stream* stm = nullptr;
        error = dev->GetStreamSqCqManage()->GetStreamById(logicSq->GetStreamId(), &stm);
        // ...
        /* update sq cq info */
        stm->UpdateSqCq(&(sqCqArray_[index]));
        logicSq->SetRtsqId(static_cast<uint16_t>(sqCqArray_[index].sqId));
        uint64_t sqIdTmp = logicSq->GetRtsqId();

        /* prepare sq switch Info */
        switchInfo_[index].stream_id = static_cast<uint32_t>(stm->Id_());
        switchInfo_[index].sq_id = logicSq->GetRtsqId();
        switchInfo_[index].sq_depth = logicSq->GetLogicSqDepth();
        // only for A5
        switchInfo_[index].stream_mem = logicSq->GetDeviceSqeAddr();
        // sqIdMemAddr_ 已转移给 LogicSq（endcap 时 BuildOneLogicSq 中转移）。
        LogicSqManage* mgr = dev->GetLogicSqManage();
        // rtsqId_ 已设置，绑定到 logicSqId（供 CQE 回收路径经 report.sqId 查 logicSq）
        (void)mgr->BindRtsqToLogicSq(logicSq->GetRtsqId(), logicSq->Id_());
        error = dev->Driver_()->MemCopySync(
            RtValueToPtr<void*>(logicSq->GetSqIdMemAddr()), sizeof(uint64_t), RtPtrToPtr<void*>(&(sqIdTmp)),
            sizeof(uint64_t), RT_MEMCPY_HOST_TO_DEVICE);
        // ...
        index++;
    }

    /* switch stream to sq */
    error = dev->Driver_()->SqSwitchStreamBatch(dev->Id_(), switchInfo_, sqCqNum_);
    // ...
}

// feature/aclgraph/capture_model.cc:1837
rtError_t CaptureModel::ConfigLogicSqTail(void) const
{
    for (LogicSq* logicSq : logicSqs_) {
        COND_RETURN_ERROR(
            logicSq->GetRtsqId() == MAX_UINT16_NUM, RT_ERROR_INVALID_VALUE, /* ... */);
        error = dev->Driver_()->SetSqTail(dev->Id_(), dev->DevGetTsId(), logicSq->GetRtsqId(), logicSq->GetSqeNum());
        // ...
    }
    return RT_ERROR_NONE;
}

// feature/aclgraph/capture_model.cc:295 / :330
rtError_t CaptureModel::SetNotifyBeforeExecute(Stream* const exeStm, CaptureModel* const captureMdl)
rtError_t CaptureModel::SetNotifyAfterExecute(Stream* const exeStm, CaptureModel* const captureMdl)

// feature/aclgraph/capture_model.cc:600
rtError_t CaptureModel::PostModelExecute(Stream* const stm, ExternalEventRefreshInfo* refreshInfo)
{
    // ...
    error = EvtRecord(executionOrderEvent_, stm);      // ← 记一个 Event
    // ...
}

// feature/aclgraph/capture_model.cc:535
rtError_t error = AddPreviousExecutionDependency(stm);   // 等上次执行完

// core/inc/model/capture_model.hpp:66
struct ExternalEventRefreshInfo {
    // ...
};

// core/inc/cond_handle/cond_handle.hpp
class CondHandle : public NoCopy {
public:
    rtError_t Setup(Context* ctx, uint32_t defaultValue);
    rtError_t Destroy();
    rtError_t InitCondTaskByDefValue(Stream* const stm);
    void SubModelDestroy();
    // ...
private:
    Model* model_{nullptr};
    uint64_t defaultValue_{0U};
    rtCondHandleFlag_t flag_;
    rtCondTaskType_t condType_{RT_COND_TASK_TYPE_MAX};
    uint32_t condSize_{0U};
    uint64_t* devAddr_{nullptr};                 // ← device 侧条件值
    Context* context_{nullptr};
    std::vector<Model*> subCaptureModels_;       // ← 分支列表
    Notify* subModelNotify_{nullptr};            // ← 所有分支共用一个
};

// feature/aclgraph/cond_handle.cc:73
rtError_t CondHandle::Setup(Context* ctx, uint32_t defaultValue)
{
    context_ = ctx;
    Device* dev = ctx->Device_();
    Driver* driver = dev->Driver_();

    void* devAddr = nullptr;
    rtError_t error = driver->DevMemAllocWithBackupFlag(
        &devAddr, sizeof(uint64_t), RT_MEMORY_DEFAULT, dev->Id_(), DevMemBackupType::SNAPSHOT_OPTIONAL_BACKUP);
    // ...
    devAddr_ = static_cast<uint64_t*>(devAddr);
    error = driver->MemSetSync(devAddr_, sizeof(uint64_t), 0U, sizeof(uint64_t));
    // ...
    void* hostPtr = nullptr;
    error = driver->HostMemAlloc(&hostPtr, sizeof(uint64_t), dev->Id_());
    // ...
    defaultValue_ = RtPtrToPtr<uint64_t*>(hostPtr);
    *defaultValue_ = defaultValue;      // ← 注意：存的是指针，不是值

    InitEmbeddedInnerHandle(this);
    CaptureModel* captureModel = dynamic_cast<CaptureModel*>(model_);
    captureModel->ModelPushBackCondHandle(this);
    return RT_ERROR_NONE;
}

// feature/aclgraph/cond_handle.cc:146
rtError_t CondHandle::InitCondTaskByDefValue(Stream* const stm)
{
    if (flag_ != RT_COND_HANDLE_ASSIGN_DEFAULT) {
        return RT_ERROR_NONE;
    }
    // 默认值初始化须在模型执行任务之前，异步拷贝任务可以天然保证默认值刷新的时机正确性。
    // defaultValue_ 构造后不变，可直接作为拷贝任务的 host 源
    uint64_t realSize = 0;
    const rtError_t error = MemcopyAsync(
        devAddr_, sizeof(uint64_t), defaultValue_, sizeof(uint64_t), RT_MEMCPY_HOST_TO_DEVICE, stm, &realSize);
    // ...
}

// core/src/task/inc/aclgraph_cond_task.h:20-24
constexpr uint8_t COND_TASK_IF_SWITCH_TASK_NUM = 2U;
constexpr uint8_t COND_TASK_WHILE_TASK_NUM = 3U;
constexpr uint8_t COND_TASK_RESV_LEN_FOR_COND_EXECUTE = 32U;   // 预留32字节存放headSqArrAddr等
constexpr uint8_t COND_TASK_IF_SWITCH_SQE_NUM = 2U;
constexpr uint8_t COND_TASK_WHILE_SQE_NUM = 3U;

constexpr uint8_t COND_TASK_RESV_LEN_FOR_COND_EXECUTE =
    32U; // 预留32字节长度，用于存放headSqArrAddr、headSqArrMax、streamSvmArrAddr

Notify* subModelNotify_{nullptr};    // 所有条件子图共用同一个

RT_FEATURE_MODEL_ACL_GRAPH_SOFTWARE_ENABLE     // 设备特性
TS_FEATURE_SOFTWARE_SQ_ENABLE                  // TS 上报
FEATURE_TRSDRV_SQ_SUPPORT_DYNAMIC_BIND         // 驱动上报

// feature/aclgraph/stream_capture.cc:237
void StreamCapture::Terminate(Stream* stm)
{
    stm->SetCaptureStatus(RT_STREAM_CAPTURE_STATUS_INVALIDATED);
    Stream* const curCaptureStream = stm->GetCaptureStream();
    if (curCaptureStream != nullptr) {
        CaptureModel* const captureModel = static_cast<CaptureModel*>(curCaptureStream->Model_());
        if (captureModel != nullptr) {
            captureModel->TerminateCapture();
        }
    }
}