Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 :
11 : #include "ccu_dev_mgr_imp.h"
12 :
13 : #include "hccl_common.h"
14 : #include "eid_info_mgr.h"
15 :
16 : #include "ccu_comp.h"
17 : #include "ccu_res_specs.h"
18 : #include "ccu_res_batch_allocator.h"
19 :
20 : // 支持ccu新老通信域混跑临时添加
21 : #include "unified_platform/ccu/ccu_device/ccu_component/ccu_component.h"
22 : #include "unified_platform/ccu/ccu_device/ccu_res_specs.h"
23 : #include "unified_platform/ccu/ccu_device/ccu_res_batch_allocator.h"
24 : #include "orion_adpt_utils.h"
25 : #include "exception_handler.h"
26 :
27 : /* 开源自定义算子CCU设备管理实现，当前支持新老通信域混跑，
28 : * 暂时改用legacy数据结构，避免反向依赖
29 : * #include "ccu_comp.h"
30 : * #include "ccu_res_specs.h"
31 : * #include "ccu_res_batch_allocator.h"
32 : */
33 :
34 : // 引入主板类型查询接口，后续应根据ccu驱动提供的信息用于判断
35 : // 当前先简化修改
36 : #include "./ccu_res_specs.h"
37 : #include "adapter_rts.h"
38 :
39 : #include "ccu_types.h"
40 : #include "ccu_log.h"
41 : #include "ccu_res_desc.h"
42 :
43 : #include "dev_type.h"
44 :
45 : namespace hcomm {
46 :
47 : static std::unordered_map<int32_t, std::shared_ptr<CcuDrvHandle>> ccuDrvHandleMap;
48 : static std::mutex ccuDrvHandleMutex;
49 : static bool ccuDriverInitAgainFlag = false; // 记录每个进程CCU驱动是否重复拉起
50 : static thread_local Hccl::HcclMainboardId mainBoardType = Hccl::HcclMainboardId::MAINBOARD_OTHERS; // 记录本卡的主板类型
51 :
52 11 : inline bool CheckCcuOpenSourceEnable()
53 : {
54 : // A6 不支持legacy ccu mc2，可以完全切换至开源流程
55 11 : auto devType = DevType::DEV_TYPE_COUNT;
56 11 : (void)hrtGetDeviceType(devType);
57 11 : return devType == DevType::DEV_TYPE_960;
58 : }
59 :
60 54 : CcuResult CcuInitFeature(const int32_t devLogicId, std::shared_ptr<CcuDrvHandle> &ccuDrvHandle)
61 : {
62 54 : if (devLogicId >= static_cast<int32_t>(MAX_MODULE_DEVICE_NUM)) {
63 0 : HCCL_ERROR("[%s] failed, devLogicId[%d] is too large, should be less than %u.",
64 : __func__, devLogicId, MAX_MODULE_DEVICE_NUM);
65 0 : return CcuResult::CCU_E_PARA;
66 : }
67 :
68 54 : std::lock_guard<std::mutex> lock(ccuDrvHandleMutex);
69 : // ccu驱动已重复拉起失败时，直接返回，在锁保护内返回
70 54 : if (ccuDriverInitAgainFlag) {
71 0 : return CcuResult::CCU_E_DRV_BUSY;
72 : }
73 :
74 54 : auto iter = ccuDrvHandleMap.find(devLogicId);
75 54 : if (iter != ccuDrvHandleMap.end()) {
76 0 : ccuDrvHandle = iter->second;
77 0 : HCCL_RUN_INFO("[%s] devLogicId[%d] init ccu feature, handle[%p].",
78 : __func__, devLogicId, ccuDrvHandle.get());
79 0 : return CcuResult::CCU_SUCCESS;
80 : }
81 :
82 54 : std::shared_ptr<CcuDrvHandle> drvHandle = nullptr;
83 54 : drvHandle.reset(new (std::nothrow) CcuDrvHandle(devLogicId));
84 54 : CCU_CHK_PTR_NULL(drvHandle);
85 :
86 54 : auto ret = drvHandle->Init();
87 54 : if (ret == CcuResult::CCU_E_DRV_BUSY) {
88 0 : HCCL_RUN_WARNING("[%s] failed but passed, devLogicId[%d] ccu driver has been "
89 : "inited by another process, this process will not try to init anymore.",
90 : __func__, devLogicId);
91 0 : ccuDriverInitAgainFlag = true; // 记录该进程ccu驱动已拉起失败
92 0 : drvHandle = nullptr; // 主动置空触发资源销毁，控制释放时序
93 0 : return ret;
94 : }
95 54 : CCU_CHK_RET(ret);
96 :
97 53 : ccuDrvHandleMap[devLogicId] = drvHandle;
98 53 : ccuDrvHandle = ccuDrvHandleMap[devLogicId];
99 53 : HCCL_RUN_INFO("[%s] devLogicId[%d] init ccu feature, handle[%p].",
100 : __func__, devLogicId, ccuDrvHandle.get());
101 53 : return CcuResult::CCU_SUCCESS;
102 54 : }
103 :
104 53 : CcuResult CcuDeinitFeature(const int32_t devLogicId)
105 : {
106 53 : std::lock_guard<std::mutex> lock(ccuDrvHandleMutex);
107 53 : auto iter = ccuDrvHandleMap.find(devLogicId);
108 53 : if (iter == ccuDrvHandleMap.end()) {
109 0 : HCCL_INFO("[%s] passed, ccu feature was not inited, devLogicId[%d].",
110 : __func__, devLogicId);
111 0 : return CcuResult::CCU_SUCCESS;
112 : }
113 :
114 53 : auto &ccuDrvHandle = ccuDrvHandleMap[devLogicId];
115 53 : if (ccuDrvHandle.use_count() == 1) {
116 53 : HCCL_RUN_INFO("[%s] entry, start to deinit ccu feature, "
117 : "handle[%p] devLogicId[%d].",
118 : __func__, ccuDrvHandle.get(), devLogicId);
119 53 : ccuDrvHandle = nullptr;
120 53 : ccuDrvHandleMap.erase(devLogicId);
121 : }
122 :
123 53 : return CcuResult::CCU_SUCCESS;
124 53 : }
125 :
126 0 : CcuResult CcuGetDieEnableInfo(int32_t deviceLogicId, uint8_t dieId, bool &enableFlag)
127 : {
128 0 : CHK_PRT_RET(dieId >= CCU_MAX_IODIE_NUM,
129 : HCCL_ERROR("[%s] failed, dieId[%u] is invalid, should be in [0-%u), devLogicId[%d].",
130 : __func__, dieId, CCU_MAX_IODIE_NUM, deviceLogicId),
131 : CcuResult::CCU_E_PARA);
132 :
133 0 : const auto &dieEnableFlags = CheckCcuOpenSourceEnable() ?
134 0 : CcuComponent::GetInstance(deviceLogicId).GetDieEnableFlags() :
135 0 : Hccl::CcuComponent::GetInstance(deviceLogicId).GetDieEnableFlags();
136 :
137 0 : enableFlag = dieEnableFlags[dieId];
138 0 : return CcuResult::CCU_SUCCESS;
139 : }
140 :
141 : // 查询指定 die 上各资源类型可分配的总量
142 2 : CcuResult CcuGetLoopEngineNum(int32_t deviceLogicId, uint8_t dieId, uint32_t &num)
143 : {
144 2 : CCU_CHK_RET(CcuDevMgrImp::GetAllocatableMaxLoopEngineNum(deviceLogicId, dieId, num));
145 2 : return CcuResult::CCU_SUCCESS;
146 : }
147 :
148 2 : CcuResult CcuGetMsNum(int32_t deviceLogicId, uint8_t dieId, uint32_t &num)
149 : {
150 2 : CCU_CHK_RET(CcuDevMgrImp::GetAllocatableMaxMsNum(deviceLogicId, dieId, num));
151 2 : return CcuResult::CCU_SUCCESS;
152 : }
153 :
154 2 : CcuResult CcuGetCkeNum(int32_t deviceLogicId, uint8_t dieId, uint32_t &num)
155 : {
156 2 : CCU_CHK_RET(CcuDevMgrImp::GetAllocatableMaxCkeNum(deviceLogicId, dieId, num));
157 2 : return CcuResult::CCU_SUCCESS;
158 : }
159 :
160 2 : CcuResult CcuGetXnNum(int32_t deviceLogicId, uint8_t dieId, uint32_t &num)
161 : {
162 2 : CCU_CHK_RET(CcuDevMgrImp::GetAllocatableMaxXnNum(deviceLogicId, dieId, num));
163 2 : return CcuResult::CCU_SUCCESS;
164 : }
165 :
166 2 : CcuResult CcuGetGsaNum(int32_t deviceLogicId, uint8_t dieId, uint32_t &num)
167 : {
168 2 : CCU_CHK_RET(CcuDevMgrImp::GetAllocatableMaxGsaNum(deviceLogicId, dieId, num));
169 2 : return CcuResult::CCU_SUCCESS;
170 : }
171 :
172 2 : CcuResult CcuGetInstructionNum(int32_t deviceLogicId, uint8_t dieId, uint32_t &num)
173 : {
174 2 : CCU_CHK_RET(CcuDevMgrImp::GetResSpecsInstructionNum(deviceLogicId, dieId, num));
175 2 : return CcuResult::CCU_SUCCESS;
176 : }
177 :
178 2 : CcuResult CcuGetMissionNum(int32_t deviceLogicId, uint8_t dieId, uint32_t &num)
179 : {
180 2 : CCU_CHK_RET(CcuDevMgrImp::GetResSpecsMissionNum(deviceLogicId, dieId, num));
181 2 : return CcuResult::CCU_SUCCESS;
182 : }
183 :
184 0 : HcclResult CcuGetMainboardType(uint32_t deviceLogicId, Hccl::HcclMainboardId &hcclMainboardId)
185 : {
186 0 : CHK_RET(CcuGetMainboardId(deviceLogicId, hcclMainboardId));
187 0 : return HcclResult::HCCL_SUCCESS;
188 : }
189 :
190 : // 单个描述符的资源数量映射到 CcuResReq 的 block 字段
191 100 : static CcuResult FillResReqByResDesc(CcuResReq &resReq, uint8_t dieId, const CcuResDesc &desc)
192 : {
193 100 : uint32_t num = 0;
194 100 : CCU_CHK_RET(desc.QueryResNum(ResType::LOOP, num));
195 100 : resReq.blockLoopEngineReq[dieId] = num;
196 100 : CCU_CHK_RET(desc.QueryResNum(ResType::MS, num));
197 100 : resReq.blockMsReq[dieId] = num;
198 100 : CCU_CHK_RET(desc.QueryResNum(ResType::CKE, num));
199 100 : resReq.blockCkeReq[dieId] = num;
200 100 : CCU_CHK_RET(desc.QueryResNum(ResType::XN, num));
201 100 : resReq.blockXnReq[dieId] = num;
202 100 : CCU_CHK_RET(desc.QueryResNum(ResType::GSA, num));
203 100 : resReq.blockGsaReq[dieId] = num;
204 :
205 100 : resReq.loopEngineReq[dieId] = 0;
206 100 : resReq.msReq[dieId] = 0;
207 100 : resReq.ckeReq[dieId] = 0;
208 100 : resReq.xnReq[dieId] = 0;
209 100 : resReq.gsaReq[dieId] = 0;
210 100 : return CcuResult::CCU_SUCCESS;
211 : }
212 :
213 : // 查询各 die 是否启用；若全部未启用则返回错误
214 50 : static CcuResult CheckEnabledDies(int32_t deviceLogicId, std::array<bool, CCU_MAX_IODIE_NUM> &dieEnableFlags)
215 : {
216 50 : dieEnableFlags = {false, false};
217 150 : for (uint8_t dieId = 0; dieId < CCU_MAX_IODIE_NUM; dieId++) {
218 100 : CCU_CHK_RET(CcuGetDieEnableInfo(deviceLogicId, dieId, dieEnableFlags[dieId]));
219 : }
220 :
221 50 : if (!dieEnableFlags[0] && !dieEnableFlags[1]) {
222 0 : HCCL_ERROR("[%s] failed, all ccu dies are disable, devLogicId[%d].", __func__, deviceLogicId);
223 0 : return CcuResult::CCU_E_INTERNAL;
224 : }
225 50 : return CcuResult::CCU_SUCCESS;
226 : }
227 :
228 : // 根据资源描述符数组构造 CcuResReq：
229 : // 跳过未启用 die；block 字段由各 die 的 resDesc 填充；
230 : // missionReq 取所有 die 的最大值，再统一回填到各启用 die
231 50 : static CcuResult BuildResReqByDescs(const CcuResDesc *descs[], uint32_t descNum,
232 : const std::array<bool, CCU_MAX_IODIE_NUM> &dieEnableFlags, int32_t deviceLogicId, CcuResReq &resReq)
233 : {
234 50 : resReq = CcuResReq{};
235 50 : resReq.missionReq.reqType = MissionReqType::FUSION_MULTIPLE_DIE;
236 :
237 50 : uint32_t maxMissionReq = 0;
238 150 : for (uint32_t i = 0; i < descNum; i++) {
239 100 : if (descs[i] == nullptr) {
240 0 : HCCL_ERROR("[%s] failed, descs[%u] is nullptr, devLogicId[%d].", __func__, i, deviceLogicId);
241 0 : return CcuResult::CCU_E_PARA;
242 : }
243 100 : uint8_t dieId = 0;
244 100 : dieId = static_cast<uint8_t>(descs[i]->dieId);
245 100 : if (dieId >= CCU_MAX_IODIE_NUM) {
246 0 : HCCL_ERROR("[%s] failed, dieId[%u] is invalid, devLogicId[%d].", __func__, dieId, deviceLogicId);
247 0 : return CcuResult::CCU_E_PARA;
248 : }
249 :
250 : // 不跳过未启用的die，如果die未启用，但请求资源，在分配资源时检查返回错误
251 100 : CCU_CHK_RET(FillResReqByResDesc(resReq, dieId, *descs[i]));
252 100 : uint32_t missionNum = 0;
253 100 : CCU_CHK_RET(descs[i]->QueryResNum(ResType::MISSION, missionNum));
254 100 : if (missionNum > maxMissionReq) {
255 50 : maxMissionReq = missionNum;
256 : }
257 : }
258 :
259 50 : if (maxMissionReq > 0) {
260 150 : for (uint8_t dieId = 0; dieId < CCU_MAX_IODIE_NUM; dieId++) {
261 100 : if (dieEnableFlags[dieId]) {
262 100 : resReq.missionReq.req[dieId] = maxMissionReq;
263 : }
264 : }
265 : }
266 50 : return CcuResult::CCU_SUCCESS;
267 : }
268 :
269 50 : CcuResult CcuAllocResHandleByResDescs(int32_t deviceLogicId,
270 : const CcuResDesc *descs[], uint32_t descNum, CcuResHandle &resHandle)
271 : {
272 50 : if (descs == nullptr || descNum == 0 || descNum > hcomm::CCU_MAX_IODIE_NUM) {
273 0 : HCCL_ERROR("[%s] failed, invalid descs[%p] descNum[%u], devLogicId[%d].", __func__, descs, descNum, deviceLogicId);
274 0 : return CcuResult::CCU_E_PARA;
275 : }
276 :
277 50 : std::array<bool, CCU_MAX_IODIE_NUM> dieEnableFlags = {false, false};
278 50 : CCU_CHK_RET(CheckEnabledDies(deviceLogicId, dieEnableFlags));
279 :
280 50 : CcuResReq resReq{};
281 50 : CCU_CHK_RET(BuildResReqByDescs(descs, descNum, dieEnableFlags, deviceLogicId, resReq));
282 :
283 50 : if (mainBoardType == Hccl::HcclMainboardId::MAINBOARD_OTHERS) {
284 1 : CCU_CHK_RET(CcuGetMainboardId(deviceLogicId, mainBoardType));
285 : }
286 :
287 50 : CCU_CHK_RET(CcuDevMgrImp::AllocResHandle(deviceLogicId, resReq, resHandle));
288 :
289 50 : HCCL_INFO("[%s] succeed, get res handle[%llx], devLogicId[%d], descNum[%u]",
290 : __func__, resHandle, deviceLogicId, descNum);
291 50 : return CcuResult::CCU_SUCCESS;
292 : }
293 :
294 : constexpr u32 CCU_MS_DEFAULT_BLOCK_LOOP_ENGINE_REQ = 8 * 8 * 2;
295 : constexpr u32 CCU_MS_DEFAULT_BLOCK_MS_REQ = 64 * 8 * 2;
296 : constexpr u32 CCU_MS_DEFAULT_BLOCK_CKE_REQ = 32 + 8 * 8 * 2;
297 : constexpr u32 CCU_MS_DEFAULT_BLOCK_XN_REQ = 400;
298 : constexpr u32 CCU_MS_DEFAULT_GSA_REQ = 400;
299 : constexpr u32 CCU_MS_DEFAULT_MISSIONREQ_REQ = 2;
300 0 : inline void ConfigCcuResReqCcuMs(CcuResReq &resReq, uint8_t dieId, CcuVersion version)
301 : {
302 0 : resReq.loopEngineReq[dieId] = 0;
303 0 : resReq.blockLoopEngineReq[dieId] = CCU_MS_DEFAULT_BLOCK_LOOP_ENGINE_REQ;
304 0 : resReq.msReq[dieId] = 0;
305 0 : resReq.blockMsReq[dieId] = CCU_MS_DEFAULT_BLOCK_MS_REQ;
306 0 : resReq.ckeReq[dieId] = 0;
307 0 : resReq.blockCkeReq[dieId] = CCU_MS_DEFAULT_BLOCK_CKE_REQ;
308 0 : resReq.xnReq[dieId] = 0;
309 0 : resReq.gsaReq[dieId] = 0;
310 0 : if (version == CcuVersion::CCU_V2) {
311 0 : resReq.blockXnReq[dieId] = CCU_MS_DEFAULT_BLOCK_XN_REQ * 2; // V2场景下申请2倍的Xn数量
312 0 : resReq.blockGsaReq[dieId] = 0;
313 : } else {
314 0 : resReq.blockXnReq[dieId] = CCU_MS_DEFAULT_BLOCK_XN_REQ;
315 0 : resReq.blockGsaReq[dieId] = CCU_MS_DEFAULT_GSA_REQ;
316 : }
317 0 : resReq.missionReq.reqType = MissionReqType::FUSION_MULTIPLE_DIE;
318 0 : resReq.missionReq.req[dieId] = CCU_MS_DEFAULT_MISSIONREQ_REQ;
319 0 : }
320 :
321 : constexpr u32 CCU_SCHED_DEFAULT_BLOCK_LOOP_ENGINE_REQ = 16;
322 : constexpr u32 CCU_SCHED_DEFAULT_BLOCK_MS_REQ = 128;
323 : constexpr u32 CCU_SCHED_DEFAULT_BLOCK_CKE_REQ = 32 + 16;
324 : constexpr u32 CCU_SCHED_DEFAULT_BLOCK_XN_REQ = 400;
325 : constexpr u32 CCU_SCHED_DEFAULT_GSA_REQ = 400;
326 : constexpr u32 CCU_SCHED_DEFAULT_MISSIONREQ_REQ = 2;
327 4 : inline void ConfigCcuResReqCcuSched(CcuResReq &resReq, uint8_t dieId, CcuVersion version)
328 : {
329 4 : resReq.loopEngineReq[dieId] = 0;
330 4 : resReq.blockLoopEngineReq[dieId] = CCU_SCHED_DEFAULT_BLOCK_LOOP_ENGINE_REQ;
331 4 : resReq.msReq[dieId] = 0;
332 4 : resReq.blockMsReq[dieId] = CCU_SCHED_DEFAULT_BLOCK_MS_REQ;
333 4 : resReq.ckeReq[dieId] = 0;
334 4 : resReq.blockCkeReq[dieId] = CCU_SCHED_DEFAULT_BLOCK_CKE_REQ;
335 4 : resReq.xnReq[dieId] = 0;
336 4 : resReq.gsaReq[dieId] = 0;
337 4 : if (version == CcuVersion::CCU_V2) {
338 0 : resReq.blockXnReq[dieId] = CCU_SCHED_DEFAULT_BLOCK_XN_REQ * 2; // V2场景下申请2倍的Xn数量
339 0 : resReq.blockGsaReq[dieId] = 0;
340 : } else {
341 4 : resReq.blockXnReq[dieId] = CCU_SCHED_DEFAULT_BLOCK_XN_REQ;
342 4 : resReq.blockGsaReq[dieId] = CCU_SCHED_DEFAULT_GSA_REQ;
343 : }
344 :
345 4 : resReq.missionReq.reqType = MissionReqType::FUSION_MULTIPLE_DIE;
346 4 : resReq.missionReq.req[dieId] = CCU_SCHED_DEFAULT_MISSIONREQ_REQ;
347 4 : }
348 :
349 : // CCU设备管理对集合通信提供的接口
350 2 : CcuResult CcuAllocResHandleByInsType(int32_t deviceLogicId,
351 : CcuInstanceType ccuInsType, CcuResHandle &resHandle)
352 : {
353 2 : if (ccuInsType >= CcuInstanceType::CCU_UNUSED) {
354 0 : HCCL_ERROR("[%s] failed, error ccu instance type[%d], devLogicId[%d].",
355 : __func__, ccuInsType, deviceLogicId);
356 0 : return CcuResult::CCU_E_PARA;
357 : }
358 :
359 2 : std::array<bool, CCU_MAX_IODIE_NUM> dieEnableFlags = {false, false};
360 6 : for (uint8_t dieId = 0; dieId < CCU_MAX_IODIE_NUM; dieId++) {
361 4 : CCU_CHK_RET(CcuGetDieEnableInfo(deviceLogicId, dieId, dieEnableFlags[dieId]));
362 : }
363 :
364 2 : if (!dieEnableFlags[0] && !dieEnableFlags[1]) {
365 0 : HCCL_ERROR("[%s] failed, all ccu dies are disable, devLogicId[%d].",
366 : __func__, deviceLogicId);
367 0 : return CcuResult::CCU_E_INTERNAL;
368 : }
369 :
370 2 : CcuVersion ccuVersion = CcuVersion::INVALID;
371 2 : CCU_CHK_RET(CcuDevMgrImp::GetCcuVersion(deviceLogicId, ccuVersion));
372 2 : if (ccuVersion == CcuVersion::INVALID) {
373 0 : HCCL_RUN_WARNING("[%s] failed, deviceLogicId[%d] ccu version is invalid, "
374 : "should fallback to aicpu.", __func__, deviceLogicId);
375 0 : return CcuResult::CCU_E_UNAVAIL;
376 : }
377 :
378 2 : CcuResReq resReq{};
379 6 : for (uint8_t dieId = 0; dieId < CCU_MAX_IODIE_NUM; dieId++) {
380 4 : if (!dieEnableFlags[dieId]) {
381 0 : continue;
382 : }
383 :
384 4 : if (ccuInsType == CcuInstanceType::CCU_MS) {
385 0 : ConfigCcuResReqCcuMs(resReq, dieId, ccuVersion);
386 : } else {
387 4 : ConfigCcuResReqCcuSched(resReq, dieId, ccuVersion);
388 : }
389 : }
390 :
391 2 : if (mainBoardType == Hccl::HcclMainboardId::MAINBOARD_OTHERS) {
392 0 : CCU_CHK_RET(CcuGetMainboardId(deviceLogicId, mainBoardType));
393 : }
394 :
395 2 : if (mainBoardType == Hccl::HcclMainboardId::MAINBOARD_PCIE_STD &&
396 : ccuInsType == CcuInstanceType::CCU_MS) { // 标卡环境下配置CCU_MS拦截报错
397 0 : HCCL_ERROR("[%s] ccuInstanceType[%d] not support in %s", __func__,
398 : ccuInsType, mainBoardType.Describe().c_str());
399 0 : return CcuResult::CCU_E_NOT_SUPPORT;
400 : }
401 :
402 2 : CCU_CHK_RET(CcuDevMgrImp::AllocResHandle(deviceLogicId, resReq, resHandle));
403 :
404 2 : HCCL_INFO("[%s] succeed, get res handle[%p], devLogicId[%d]",
405 : __func__, resHandle, deviceLogicId);
406 2 : return CcuResult::CCU_SUCCESS;
407 : }
408 :
409 96 : CcuResult CcuCheckResource(const int32_t deviceLogicId, const CcuResHandle resHandle,
410 : CcuResRepository &resRepo)
411 : {
412 96 : CCU_CHK_RET(CcuDevMgrImp::GetResource(deviceLogicId, resHandle, resRepo));
413 96 : return CcuResult::CCU_SUCCESS;
414 : }
415 :
416 52 : HcclResult CcuReleaseResHandle(const int32_t deviceLogicId, const CcuResHandle resHandle)
417 : {
418 52 : CHK_RET(CcuDevMgrImp::ReleaseResHandle(deviceLogicId, resHandle));
419 52 : return HcclResult::HCCL_SUCCESS;
420 : }
421 :
422 0 : HcclResult CcuAllocChannels(const int32_t deviceLogicId,
423 : const CcuChannelPara &ccuChannelPara,
424 : std::vector<CcuChannelInfo> &ccuChannelInfos)
425 : {
426 0 : Hccl::IpAddress ipAddr{};
427 0 : CHK_RET(CommAddrToIpAddress(ccuChannelPara.commAddr, ipAddr)); // 为了打印信息暂时添加
428 0 : HCCL_INFO("[%s] new allocation request: deviceLogicId[%d], ipAddr[%s], "
429 : "channelnum[%u], jettyNum[%u], sqSize[%u].", __func__, deviceLogicId,
430 : ipAddr.Describe().c_str(), ccuChannelPara.channelNum,
431 : ccuChannelPara.jettyNum, ccuChannelPara.sqSize);
432 :
433 0 : uint32_t devPhyId{0};
434 0 : CHK_RET(hrtGetDevicePhyIdByIndex(static_cast<uint32_t>(deviceLogicId), devPhyId));
435 :
436 0 : DevEidInfo eidInfo{};
437 0 : CHK_RET(EidInfoMgr::GetInstance(devPhyId)
438 : .GetEidInfoByAddr(ccuChannelPara.commAddr, eidInfo));
439 0 : const uint8_t dieId = static_cast<uint8_t>(eidInfo.dieId);
440 0 : const uint32_t feId = eidInfo.funcId;
441 0 : ChannelPara para{};
442 0 : para.feId = feId;
443 0 : para.jettyNum = ccuChannelPara.jettyNum;
444 0 : para.sqSize = ccuChannelPara.sqSize;
445 :
446 : HcclResult ret;
447 : EXCEPTION_HANDLE_BEGIN
448 0 : ret = CheckCcuOpenSourceEnable() ?
449 0 : CcuComponent::GetInstance(deviceLogicId)
450 0 : .AllocChannels(dieId, para, ccuChannelInfos) :
451 0 : Hccl::CcuComponent::GetInstance(deviceLogicId)
452 0 : .AllocChannels(dieId, para, ccuChannelInfos);
453 0 : EXCEPTION_HANDLE_END
454 0 : return ret;
455 0 : }
456 :
457 0 : HcclResult CcuReleaseChannel(const int32_t deviceLogicId, const uint8_t dieId,
458 : const uint32_t ccuChannelId)
459 : {
460 0 : HCCL_INFO("[%s] new release request: deviceLogicId[%d], dieId[%u], "
461 : "ccuChannelId[%u].", __func__, deviceLogicId, dieId, ccuChannelId);
462 :
463 : HcclResult ret;
464 : EXCEPTION_HANDLE_BEGIN
465 0 : ret = CheckCcuOpenSourceEnable() ?
466 0 : CcuComponent::GetInstance(deviceLogicId)
467 0 : .ReleaseChannel(dieId, ccuChannelId) :
468 0 : Hccl::CcuComponent::GetInstance(deviceLogicId)
469 0 : .ReleaseChannel(dieId, ccuChannelId);
470 0 : EXCEPTION_HANDLE_END
471 0 : return ret;
472 : }
473 :
474 : // 以下为hcomm基础通信内部CCU流程使用的接口
475 0 : HcclResult CcuDevMgrImp::GetCcuVersion(const int32_t deviceLogicId, CcuVersion &ccuVersion)
476 : {
477 : EXCEPTION_HANDLE_BEGIN
478 0 : ccuVersion = CheckCcuOpenSourceEnable() ?
479 0 : CcuResSpecifications::GetInstance(deviceLogicId).GetCcuVersion() :
480 0 : Hccl::CcuResSpecifications::GetInstance(deviceLogicId).GetCcuVersion();
481 0 : EXCEPTION_HANDLE_END
482 0 : return HcclResult::HCCL_SUCCESS;
483 : }
484 :
485 0 : HcclResult CcuDevMgrImp::GetCcuResourceSpaceBufInfo(const int32_t deviceLogicId, const uint8_t dieId,
486 : uint64_t &addr, uint64_t &size)
487 : {
488 : HcclResult ret;
489 : EXCEPTION_HANDLE_BEGIN
490 0 : ret = CheckCcuOpenSourceEnable() ?
491 0 : CcuComponent::GetInstance(deviceLogicId)
492 0 : .GetCcuResourceSpaceBufInfo(dieId, addr, size) :
493 0 : Hccl::CcuComponent::GetInstance(deviceLogicId)
494 0 : .GetCcuResourceSpaceBufInfo(dieId, addr, size);
495 0 : EXCEPTION_HANDLE_END
496 0 : return ret;
497 : }
498 :
499 0 : HcclResult CcuDevMgrImp::GetCcuResourceSpaceTokenInfo(const int32_t deviceLogicId, const uint8_t dieId,
500 : uint64_t &tokenId, uint64_t &tokenValue)
501 : {
502 : HcclResult ret;
503 : EXCEPTION_HANDLE_BEGIN
504 0 : ret = CheckCcuOpenSourceEnable() ?
505 0 : CcuComponent::GetInstance(deviceLogicId)
506 0 : .GetCcuResourceSpaceTokenInfo(dieId, tokenId, tokenValue) :
507 0 : Hccl::CcuComponent::GetInstance(deviceLogicId)
508 0 : .GetCcuResourceSpaceTokenInfo(dieId, tokenId, tokenValue);
509 0 : EXCEPTION_HANDLE_END
510 0 : return ret;
511 : }
512 :
513 0 : HcclResult CcuDevMgrImp::ConfigChannel(const int32_t deviceLogicId, const uint8_t dieId,
514 : ChannelCfg &cfg)
515 : {
516 : HcclResult ret;
517 : EXCEPTION_HANDLE_BEGIN
518 0 : ret = CheckCcuOpenSourceEnable() ?
519 0 : CcuComponent::GetInstance(deviceLogicId).ConfigChannel(dieId, cfg) :
520 0 : Hccl::CcuComponent::GetInstance(deviceLogicId).ConfigChannel(dieId, cfg);
521 0 : EXCEPTION_HANDLE_END
522 0 : return ret;
523 : }
524 :
525 0 : HcclResult CcuDevMgrImp::GetLoopChannelId(const int32_t deviceLogicId, const uint8_t srcDieId,
526 : const uint8_t dstDieId, uint32_t &channIdx)
527 : {
528 : HcclResult ret;
529 : EXCEPTION_HANDLE_BEGIN
530 0 : ret = CheckCcuOpenSourceEnable() ?
531 0 : CcuComponent::GetInstance(deviceLogicId)
532 0 : .GetLoopChannelId(srcDieId, dstDieId, channIdx) :
533 0 : Hccl::CcuComponent::GetInstance(deviceLogicId)
534 0 : .GetLoopChannelId(srcDieId, dstDieId, channIdx);
535 0 : EXCEPTION_HANDLE_END
536 0 : return ret;
537 : }
538 :
539 0 : HcclResult CcuDevMgrImp::GetResource(const int32_t deviceLogicId,
540 : const CcuResHandle handle, CcuResRepository &ccuResRepo)
541 : {
542 : HcclResult ret;
543 : EXCEPTION_HANDLE_BEGIN
544 0 : ret = CheckCcuOpenSourceEnable() ?
545 0 : CcuResBatchAllocator::GetInstance(deviceLogicId)
546 0 : .GetResource(handle, ccuResRepo) :
547 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId)
548 0 : .GetResource(handle, ccuResRepo);
549 0 : EXCEPTION_HANDLE_END
550 0 : return ret;
551 : }
552 :
553 0 : HcclResult CcuDevMgrImp::AllocResHandle(const int32_t deviceLogicId, const CcuResReq resReq,
554 : CcuResHandle &handle)
555 : {
556 : HcclResult ret;
557 : EXCEPTION_HANDLE_BEGIN
558 0 : ret = CheckCcuOpenSourceEnable() ?
559 0 : CcuResBatchAllocator::GetInstance(deviceLogicId)
560 0 : .AllocResHandle(resReq, handle) :
561 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId)
562 0 : .AllocResHandle(resReq, handle);
563 0 : EXCEPTION_HANDLE_END
564 0 : return ret;
565 : }
566 :
567 0 : HcclResult CcuDevMgrImp::ReleaseResHandle(const int32_t deviceLogicId,
568 : const CcuResHandle handle)
569 : {
570 : HcclResult ret;
571 : EXCEPTION_HANDLE_BEGIN
572 0 : ret = CheckCcuOpenSourceEnable() ?
573 0 : CcuResBatchAllocator::GetInstance(deviceLogicId)
574 0 : .ReleaseResHandle(handle) :
575 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId)
576 0 : .ReleaseResHandle(handle);
577 0 : EXCEPTION_HANDLE_END
578 0 : return ret;
579 : }
580 :
581 0 : HcclResult CcuDevMgrImp::QueryRemainRes(const int32_t deviceLogicId, const uint8_t dieId, const ResType &internalType, uint32_t &remainNum)
582 : {
583 : HcclResult ret;
584 : EXCEPTION_HANDLE_BEGIN
585 0 : ret = CheckCcuOpenSourceEnable() ?
586 0 : CcuResBatchAllocator::GetInstance(deviceLogicId).QueryRemainRes(dieId, internalType, remainNum) :
587 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId).QueryRemainRes(dieId, internalType, remainNum);
588 0 : EXCEPTION_HANDLE_END
589 0 : return ret;
590 : }
591 :
592 0 : HcclResult CcuDevMgrImp::AllocIns(const int32_t deviceLogicId, const uint8_t dieId,
593 : const uint32_t num, ResInfo &insInfo)
594 : {
595 : HcclResult ret;
596 : EXCEPTION_HANDLE_BEGIN
597 0 : ret = CheckCcuOpenSourceEnable() ?
598 0 : CcuComponent::GetInstance(deviceLogicId).AllocIns(dieId, num, insInfo) :
599 0 : Hccl::CcuComponent::GetInstance(deviceLogicId).AllocIns(dieId, num, insInfo);
600 0 : EXCEPTION_HANDLE_END
601 0 : return ret;
602 : }
603 :
604 0 : HcclResult CcuDevMgrImp::ReleaseIns(const int32_t deviceLogicId, const uint8_t dieId,
605 : const ResInfo &insInfo)
606 : {
607 : HcclResult ret;
608 : EXCEPTION_HANDLE_BEGIN
609 0 : ret = CheckCcuOpenSourceEnable() ?
610 0 : CcuComponent::GetInstance(deviceLogicId).ReleaseIns(dieId, insInfo) :
611 0 : Hccl::CcuComponent::GetInstance(deviceLogicId).ReleaseIns(dieId, insInfo);
612 0 : EXCEPTION_HANDLE_END
613 0 : return ret;
614 : }
615 :
616 3 : uint32_t CcuDevMgrImp::GetInsConsecutiveRemainSize(const int32_t deviceLogicId, const uint8_t dieId)
617 : {
618 3 : return CheckCcuOpenSourceEnable() ?
619 0 : CcuComponent::GetInstance(deviceLogicId).GetInsConsecutiveRemainSize(dieId) :
620 3 : Hccl::CcuComponent::GetInstance(deviceLogicId).GetInsConsecutiveRemainSize(dieId);
621 : }
622 :
623 0 : HcclResult CcuDevMgrImp::AllocCke(const int32_t deviceLogicId, const uint8_t dieId,
624 : const uint32_t num, std::vector<ResInfo> &ckeInfos)
625 : {
626 : HcclResult ret;
627 : EXCEPTION_HANDLE_BEGIN
628 0 : ret = CheckCcuOpenSourceEnable() ?
629 0 : CcuComponent::GetInstance(deviceLogicId).AllocCke(dieId, num, ckeInfos) :
630 0 : Hccl::CcuComponent::GetInstance(deviceLogicId).AllocCke(dieId, num, ckeInfos);
631 0 : EXCEPTION_HANDLE_END
632 0 : return ret;
633 : }
634 :
635 0 : HcclResult CcuDevMgrImp::ReleaseCke(const int32_t deviceLogicId, const uint8_t dieId,
636 : const std::vector<ResInfo> &ckeInfos)
637 : {
638 : HcclResult ret;
639 : EXCEPTION_HANDLE_BEGIN
640 0 : ret = CheckCcuOpenSourceEnable() ?
641 0 : CcuComponent::GetInstance(deviceLogicId).ReleaseCke(dieId, ckeInfos) :
642 0 : Hccl::CcuComponent::GetInstance(deviceLogicId).ReleaseCke(dieId, ckeInfos);
643 0 : EXCEPTION_HANDLE_END
644 0 : return ret;
645 : }
646 :
647 0 : HcclResult CcuDevMgrImp::AllocXn(const int32_t deviceLogicId, const uint8_t dieId,
648 : const uint32_t num, std::vector<ResInfo>& xnInfos)
649 : {
650 : HcclResult ret;
651 : EXCEPTION_HANDLE_BEGIN
652 0 : ret = CheckCcuOpenSourceEnable() ?
653 0 : CcuComponent::GetInstance(deviceLogicId).AllocXn(dieId, num, xnInfos) :
654 0 : Hccl::CcuComponent::GetInstance(deviceLogicId).AllocXn(dieId, num, xnInfos);
655 0 : EXCEPTION_HANDLE_END
656 0 : return ret;
657 : }
658 :
659 0 : HcclResult CcuDevMgrImp::ReleaseXn(const int32_t deviceLogicId, const uint8_t dieId,
660 : const std::vector<ResInfo> &xnInfos)
661 : {
662 : HcclResult ret;
663 : EXCEPTION_HANDLE_BEGIN
664 0 : ret = CheckCcuOpenSourceEnable() ?
665 0 : CcuComponent::GetInstance(deviceLogicId).ReleaseXn(dieId, xnInfos) :
666 0 : Hccl::CcuComponent::GetInstance(deviceLogicId).ReleaseXn(dieId, xnInfos);
667 0 : EXCEPTION_HANDLE_END
668 0 : return ret;
669 : }
670 :
671 0 : HcclResult CcuDevMgrImp::AllocWishCntXn(const int32_t deviceLogicId, const uint8_t dieId, const std::string &resGroupTag,
672 : uint32_t &wishCntXn)
673 : {
674 0 : if (!CheckCcuOpenSourceEnable()) {
675 0 : HCCL_WARNING("[CcuDevMgrImp][%s] is not supported for legacy interface.", __func__);
676 0 : return HcclResult::HCCL_E_NOT_SUPPORT;
677 : }
678 :
679 0 : HCCL_INFO("[%s] new alloc count xn request: deviceLogicId[%d], dieId[%u], resGroupTag[%s].",
680 : __func__, deviceLogicId, dieId, resGroupTag.c_str());
681 0 : return CcuComponent::GetInstance(deviceLogicId).AllocWishCntXn(dieId, resGroupTag, wishCntXn);
682 : }
683 :
684 0 : HcclResult CcuDevMgrImp::ReleaseWishCntXn(const int32_t deviceLogicId, const uint8_t dieId,
685 : const std::string &resGroupTag, uint32_t wishCntXn)
686 : {
687 0 : if (!CheckCcuOpenSourceEnable()) {
688 0 : HCCL_WARNING("[CcuDevMgrImp][%s] is not supported for legacy interface.", __func__);
689 0 : return HcclResult::HCCL_E_NOT_SUPPORT;
690 : }
691 :
692 0 : HCCL_INFO("[%s] new release count xn request: deviceLogicId[%d], dieId[%u], resGroupTag[%s], wishCntXn[%u].",
693 : __func__, deviceLogicId, dieId, resGroupTag.c_str(), wishCntXn);
694 0 : return CcuComponent::GetInstance(deviceLogicId).ReleaseWishCntXn(dieId, resGroupTag, wishCntXn);
695 : }
696 :
697 0 : HcclResult CcuDevMgrImp::GetCntXnBlock(const int32_t deviceLogicId, const uint8_t dieId,
698 : const std::string &resGroupTag, std::pair<uint32_t, uint32_t> &cntXnPair)
699 : {
700 0 : if (!CheckCcuOpenSourceEnable()) {
701 0 : HCCL_WARNING("[CcuDevMgrImp][%s] is not supported for legacy interface.", __func__);
702 0 : return HcclResult::HCCL_E_NOT_SUPPORT;
703 : }
704 :
705 0 : HCCL_INFO("[%s] get count xn request: deviceLogicId[%d], dieId[%u], resGroupTag[%s].",
706 : __func__, deviceLogicId, dieId, resGroupTag.c_str());
707 0 : return CcuComponent::GetInstance(deviceLogicId).GetCntXnBlock(dieId, resGroupTag, cntXnPair);
708 : }
709 :
710 0 : HcclResult CcuDevMgrImp::GetTotalCntXn(const int32_t deviceLogicId, const uint8_t dieId,
711 : const std::string &resGroupTag, uint32_t &totalCntXn)
712 : {
713 0 : if (!CheckCcuOpenSourceEnable()) {
714 0 : HCCL_WARNING("[CcuDevMgrImp][%s] is not supported for legacy interface.", __func__);
715 0 : return HcclResult::HCCL_E_NOT_SUPPORT;
716 : }
717 :
718 0 : HCCL_INFO("[%s] get count xn request: deviceLogicId[%d], dieId[%u], resGroupTag[%s].",
719 : __func__, deviceLogicId, dieId, resGroupTag.c_str());
720 0 : return CcuComponent::GetInstance(deviceLogicId).GetTotalCntXn(dieId, resGroupTag, totalCntXn);
721 : }
722 :
723 0 : HcclResult CcuDevMgrImp::GetMissionKey(const int32_t deviceLogicId, const uint8_t dieId,
724 : uint32_t &missionKey)
725 : {
726 : HcclResult ret;
727 : EXCEPTION_HANDLE_BEGIN
728 0 : ret = CheckCcuOpenSourceEnable() ?
729 0 : CcuResSpecifications::GetInstance(deviceLogicId)
730 0 : .GetMissionKey(dieId, missionKey) :
731 0 : Hccl::CcuResSpecifications::GetInstance(deviceLogicId)
732 0 : .GetMissionKey(dieId, missionKey);
733 0 : EXCEPTION_HANDLE_END
734 0 : return ret;
735 : }
736 :
737 0 : HcclResult CcuDevMgrImp::GetResSpecsInstructionNum(const int32_t deviceLogicId, const uint8_t dieId,
738 : uint32_t &instrNum)
739 : {
740 : HcclResult ret;
741 : EXCEPTION_HANDLE_BEGIN
742 0 : ret = CheckCcuOpenSourceEnable() ?
743 0 : CcuResSpecifications::GetInstance(deviceLogicId)
744 0 : .GetInstructionNum(dieId, instrNum) :
745 0 : Hccl::CcuResSpecifications::GetInstance(deviceLogicId)
746 0 : .GetInstructionNum(dieId, instrNum);
747 0 : EXCEPTION_HANDLE_END
748 0 : return ret;
749 : }
750 :
751 0 : HcclResult CcuDevMgrImp::GetAllocatableMaxLoopEngineNum(const int32_t deviceLogicId, const uint8_t dieId,
752 : uint32_t &loopNum)
753 : {
754 : HcclResult ret;
755 : EXCEPTION_HANDLE_BEGIN
756 0 : ret = CheckCcuOpenSourceEnable() ?
757 0 : CcuResBatchAllocator::GetInstance(deviceLogicId)
758 0 : .GetAllocatableMaxBlockResNum(ResType::LOOP, dieId, loopNum) :
759 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId)
760 0 : .GetAllocatableMaxBlockResNum(ResType::LOOP, dieId, loopNum);
761 0 : EXCEPTION_HANDLE_END
762 0 : return ret;
763 : }
764 :
765 0 : HcclResult CcuDevMgrImp::GetAllocatableMaxMsNum(const int32_t deviceLogicId, const uint8_t dieId, uint32_t &msNum)
766 : {
767 : HcclResult ret;
768 : EXCEPTION_HANDLE_BEGIN
769 0 : ret = CheckCcuOpenSourceEnable() ?
770 0 : CcuResBatchAllocator::GetInstance(deviceLogicId)
771 0 : .GetAllocatableMaxBlockResNum(ResType::MS, dieId, msNum) :
772 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId)
773 0 : .GetAllocatableMaxBlockResNum(ResType::MS, dieId, msNum);
774 0 : EXCEPTION_HANDLE_END
775 0 : return ret;
776 : }
777 :
778 0 : HcclResult CcuDevMgrImp::GetAllocatableMaxCkeNum(const int32_t deviceLogicId, const uint8_t dieId, uint32_t &ckeNum)
779 : {
780 : HcclResult ret;
781 : EXCEPTION_HANDLE_BEGIN
782 0 : ret = CheckCcuOpenSourceEnable() ?
783 0 : CcuResBatchAllocator::GetInstance(deviceLogicId)
784 0 : .GetAllocatableMaxBlockResNum(ResType::CKE, dieId, ckeNum) :
785 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId)
786 0 : .GetAllocatableMaxBlockResNum(ResType::CKE, dieId, ckeNum);
787 0 : EXCEPTION_HANDLE_END
788 0 : return ret;
789 : }
790 :
791 0 : HcclResult CcuDevMgrImp::GetAllocatableMaxXnNum(const int32_t deviceLogicId, const uint8_t dieId, uint32_t &xnNum)
792 : {
793 : HcclResult ret;
794 : EXCEPTION_HANDLE_BEGIN
795 0 : ret = CheckCcuOpenSourceEnable() ?
796 0 : CcuResBatchAllocator::GetInstance(deviceLogicId)
797 0 : .GetAllocatableMaxBlockResNum(ResType::XN, dieId, xnNum) :
798 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId)
799 0 : .GetAllocatableMaxBlockResNum(ResType::XN, dieId, xnNum);
800 0 : EXCEPTION_HANDLE_END
801 0 : return ret;
802 : }
803 :
804 0 : HcclResult CcuDevMgrImp::GetAllocatableMaxGsaNum(const int32_t deviceLogicId, const uint8_t dieId, uint32_t &gsaNum)
805 : {
806 : HcclResult ret;
807 : EXCEPTION_HANDLE_BEGIN
808 0 : ret = CheckCcuOpenSourceEnable() ?
809 0 : CcuResBatchAllocator::GetInstance(deviceLogicId)
810 0 : .GetAllocatableMaxBlockResNum(ResType::GSA, dieId, gsaNum) :
811 0 : Hccl::CcuResBatchAllocator::GetInstance(deviceLogicId)
812 0 : .GetAllocatableMaxBlockResNum(ResType::GSA, dieId, gsaNum);
813 0 : EXCEPTION_HANDLE_END
814 0 : return ret;
815 : }
816 :
817 0 : HcclResult CcuDevMgrImp::GetResSpecsMissionNum(const int32_t deviceLogicId, const uint8_t dieId,
818 : uint32_t &missionNum)
819 : {
820 : HcclResult ret;
821 : EXCEPTION_HANDLE_BEGIN
822 0 : ret = CheckCcuOpenSourceEnable() ?
823 0 : CcuResSpecifications::GetInstance(deviceLogicId)
824 0 : .GetMissionNum(dieId, missionNum) :
825 0 : Hccl::CcuResSpecifications::GetInstance(deviceLogicId)
826 0 : .GetMissionNum(dieId, missionNum);
827 0 : EXCEPTION_HANDLE_END
828 0 : return ret;
829 : }
830 :
831 0 : HcclResult CcuDevMgrImp::GetXnBaseAddr(const int32_t devLogicId, const uint8_t dieId,
832 : uint64_t& xnBaseAddr)
833 : {
834 : HcclResult ret;
835 : EXCEPTION_HANDLE_BEGIN
836 0 : ret = CheckCcuOpenSourceEnable() ?
837 0 : CcuResSpecifications::GetInstance(devLogicId)
838 0 : .GetXnBaseAddr(dieId, xnBaseAddr) :
839 0 : Hccl::CcuResSpecifications::GetInstance(devLogicId)
840 0 : .GetXnBaseAddr(dieId, xnBaseAddr);
841 0 : EXCEPTION_HANDLE_END
842 0 : return ret;
843 : }
844 0 : HcclResult CcuDevMgrImp::GetCkeBaseAddr(const int32_t devLogicId, const uint8_t dieId,
845 : uint64_t& ckeBaseAddr)
846 : {
847 0 : if (!CheckCcuOpenSourceEnable()) {
848 0 : HCCL_WARNING("[CcuDevMgrImp][%s] is not supported for legacy interface.", __func__);
849 0 : return HcclResult::HCCL_E_NOT_SUPPORT;
850 : }
851 :
852 0 : return CcuResSpecifications::GetInstance(devLogicId).GetCkeBaseAddr(dieId, ckeBaseAddr);
853 : }
854 :
855 0 : HcclResult CcuDevMgrImp::GetXnOffsetCcumAddrById(const int32_t devLogicId, const uint8_t dieId, uint16_t id,
856 : uint64_t& xnAddr)
857 : {
858 0 : if (!CheckCcuOpenSourceEnable()) {
859 0 : HCCL_WARNING("[CcuDevMgrImp][%s] is not supported for legacy interface.", __func__);
860 0 : return HcclResult::HCCL_E_NOT_SUPPORT;
861 : }
862 :
863 0 : return CcuResSpecifications::GetInstance(devLogicId).GetXnOffsetCcumAddrById(dieId, id, xnAddr);
864 : }
865 :
866 0 : HcclResult CcuDevMgrImp::GetCkeOffsetCcumAddrById(const int32_t devLogicId, const uint8_t dieId, uint16_t id,
867 : uint64_t& ckeAddr)
868 : {
869 0 : if (!CheckCcuOpenSourceEnable()) {
870 0 : HCCL_WARNING("[CcuDevMgrImp][%s] is not supported for legacy interface.", __func__);
871 0 : return HcclResult::HCCL_E_NOT_SUPPORT;
872 : }
873 :
874 0 : return CcuResSpecifications::GetInstance(devLogicId).GetCkeOffsetCcumAddrById(dieId, id, ckeAddr);
875 : }
876 :
877 2348 : HcclResult CheckDieValid(const char *funcName, const int32_t devLogicId, const uint8_t dieId,
878 : const std::array<bool, CCU_MAX_IODIE_NUM> &dieEnableFlags)
879 : {
880 2348 : CHK_PRT_RET(dieId >= CCU_MAX_IODIE_NUM,
881 : HCCL_ERROR("[%s] failed, dieId[%u] is invalid, should be in [0-%u), devLogicId[%d].",
882 : funcName, dieId, CCU_MAX_IODIE_NUM, devLogicId),
883 : HcclResult::HCCL_E_PARA);
884 :
885 2348 : CHK_PRT_RET(!dieEnableFlags[dieId],
886 : HCCL_ERROR("[%s] failed, dieId[%u] is disable, devLogicId[%d].",
887 : funcName, dieId, devLogicId),
888 : HcclResult::HCCL_E_PARA);
889 :
890 2348 : return HcclResult::HCCL_SUCCESS;
891 : }
892 :
893 0 : bool CcuIsInited(const int32_t deviceLogicId)
894 : {
895 0 : HCCL_INFO("[CcuIsInited] Input params: deviceLogicId[%d]", deviceLogicId);
896 0 : CHK_PRT_RET((deviceLogicId < 0 || static_cast<u32>(deviceLogicId) >= MAX_MODULE_DEVICE_NUM),
897 : HCCL_ERROR("[CcuIsInited]deviceLogicId[%d] error, MAX_MODULE_DEVICE_NUM[%u]", deviceLogicId, MAX_MODULE_DEVICE_NUM),
898 : false);
899 :
900 0 : if (!CheckCcuOpenSourceEnable()) {
901 0 : return Hccl::CcuComponent::GetInstance(deviceLogicId).IsInited();
902 : }
903 :
904 0 : std::lock_guard<std::mutex> lock(ccuDrvHandleMutex);
905 : // ccu驱动已重复拉起失败时，直接返回，在锁保护内返回
906 0 : if (ccuDriverInitAgainFlag) {
907 0 : return false;
908 : }
909 :
910 0 : auto iter = ccuDrvHandleMap.find(deviceLogicId);
911 0 : if (iter == ccuDrvHandleMap.end()) {
912 0 : return false;
913 : }
914 :
915 0 : return true;
916 0 : }
917 :
918 4 : HcclResult CcuSetTaskKill(const int32_t deviceLogicId)
919 : {
920 4 : HCCL_INFO("[CcuSetTaskKill] Input params: deviceLogicId[%d]", deviceLogicId);
921 : // 入参校验拦截
922 4 : CHK_PRT_RET((deviceLogicId < 0 || static_cast<u32>(deviceLogicId) >= MAX_MODULE_DEVICE_NUM),
923 : HCCL_ERROR("[CcuSetTaskKill]deviceLogicId[%d] error, MAX_MODULE_DEVICE_NUM[%u]", deviceLogicId, MAX_MODULE_DEVICE_NUM),
924 : HcclResult::HCCL_E_PARA);
925 : HcclResult ret;
926 : EXCEPTION_HANDLE_BEGIN
927 2 : ret = CheckCcuOpenSourceEnable() ?
928 0 : CcuComponent::GetInstance(deviceLogicId).SetTaskKill() :
929 2 : Hccl::CcuComponent::GetInstance(deviceLogicId).SetTaskKill();
930 0 : EXCEPTION_HANDLE_END
931 2 : return ret;
932 : }
933 :
934 4 : HcclResult CcuSetTaskKillDone(const int32_t deviceLogicId)
935 : {
936 4 : HCCL_INFO("[CcuSetTaskKillDone] Input params: deviceLogicId[%d]", deviceLogicId);
937 : // 入参校验拦截
938 4 : CHK_PRT_RET((deviceLogicId < 0 || static_cast<u32>(deviceLogicId) >= MAX_MODULE_DEVICE_NUM),
939 : HCCL_ERROR("[CcuSetTaskKillDone]deviceLogicId[%d] error, MAX_MODULE_DEVICE_NUM[%u]", deviceLogicId, MAX_MODULE_DEVICE_NUM),
940 : HcclResult::HCCL_E_PARA);
941 : HcclResult ret;
942 : EXCEPTION_HANDLE_BEGIN
943 2 : ret = CheckCcuOpenSourceEnable() ?
944 0 : CcuComponent::GetInstance(deviceLogicId).SetTaskKillDone() :
945 2 : Hccl::CcuComponent::GetInstance(deviceLogicId).SetTaskKillDone();
946 0 : EXCEPTION_HANDLE_END
947 2 : return ret;
948 : }
949 :
950 4 : HcclResult CcuCleanTaskKillState(const int32_t deviceLogicId)
951 : {
952 4 : HCCL_INFO("[CcuCleanTaskKillState] Input params: deviceLogicId[%d]", deviceLogicId);
953 : // 入参校验拦截
954 4 : CHK_PRT_RET((deviceLogicId < 0 || static_cast<u32>(deviceLogicId) >= MAX_MODULE_DEVICE_NUM),
955 : HCCL_ERROR("[CcuCleanTaskKillState]deviceLogicId[%d] error, MAX_MODULE_DEVICE_NUM[%u]", deviceLogicId, MAX_MODULE_DEVICE_NUM),
956 : HcclResult::HCCL_E_PARA);
957 : HcclResult ret;
958 : EXCEPTION_HANDLE_BEGIN
959 2 : ret = CheckCcuOpenSourceEnable() ?
960 0 : CcuComponent::GetInstance(deviceLogicId).CleanTaskKillState() :
961 2 : Hccl::CcuComponent::GetInstance(deviceLogicId).CleanTaskKillState();
962 0 : EXCEPTION_HANDLE_END
963 2 : return ret;
964 : }
965 :
966 4 : HcclResult CcuCleanDieCkes(const int32_t deviceLogicId, const uint8_t dieId)
967 : {
968 4 : HCCL_INFO("[CcuCleanDieCkes] Input params: deviceLogicId[%d], dieId[%u]", deviceLogicId, dieId);
969 : // 入参校验拦截
970 4 : CHK_PRT_RET((deviceLogicId < 0 || static_cast<u32>(deviceLogicId) >= MAX_MODULE_DEVICE_NUM),
971 : HCCL_ERROR("[CcuCleanDieCkes]deviceLogicId[%d] error, MAX_MODULE_DEVICE_NUM[%u]", deviceLogicId, MAX_MODULE_DEVICE_NUM),
972 : HcclResult::HCCL_E_PARA);
973 : HcclResult ret;
974 : EXCEPTION_HANDLE_BEGIN
975 2 : ret = CheckCcuOpenSourceEnable() ?
976 0 : CcuComponent::GetInstance(deviceLogicId).CleanDieCkes(dieId) :
977 2 : Hccl::CcuComponent::GetInstance(deviceLogicId).CleanDieCkes(dieId);
978 0 : EXCEPTION_HANDLE_END
979 2 : return ret;
980 : }
981 :
982 : }; // namespace hcomm
|
