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 "orion_adapter_rts.h"
12 : #include "runtime_api_exception.h"
13 : #include "exception_util.h"
14 : #include "invalid_params_exception.h"
15 : #include "log.h"
16 : #include "acl/acl_rt.h"
17 : #include "driver/ascend_hal.h"
18 : #include "not_support_exception.h"
19 : #include "adapter_error_manager_pub.h"
20 : #include "dlrts_function_v2.h"
21 :
22 : using namespace std;
23 : namespace Hccl {
24 :
25 : HcclResult HrtThreadExchangeCaptureMode(aclmdlRICaptureMode *mode);
26 : constexpr u32 TOKEN_ID_RIGHT_SHIF = 8; // URMA_TOKEN_ID_RIGHT_SHIF，因URMA配置原因需要右移8位
27 : namespace {
28 : constexpr char RT_SET_XPU_DEVICE[] = "rtSetXpuDevice";
29 : constexpr char RT_RESET_XPU_DEVICE[] = "rtResetXpuDevice";
30 : }
31 : const std::unordered_map<std::string, DevType> SOC_VER_CONVERT{{"Ascend310P1", DevType::DEV_TYPE_V51_310_P1},
32 : {"Ascend310P3", DevType::DEV_TYPE_V51_310_P3},
33 : {"Ascend910", DevType::DEV_TYPE_910A},
34 : {"Ascend910A", DevType::DEV_TYPE_910A},
35 : {"Ascend910B", DevType::DEV_TYPE_910A},
36 : {"Ascend910ProA", DevType::DEV_TYPE_910A},
37 : {"Ascend910ProB", DevType::DEV_TYPE_910A},
38 : {"Ascend910PremiumA", DevType::DEV_TYPE_910A},
39 : {"Ascend910B1", DevType::DEV_TYPE_910A2},
40 : {"Ascend910B2", DevType::DEV_TYPE_910A2},
41 : {"Ascend910B3", DevType::DEV_TYPE_910A2},
42 : {"Ascend910B4", DevType::DEV_TYPE_910A2},
43 : {"Ascend910B4-1", DevType::DEV_TYPE_910A2},
44 : {"Ascend910_939", DevType::DEV_TYPE_910A3},
45 : {"Ascend910_938", DevType::DEV_TYPE_910A3},
46 : {"Ascend910_937", DevType::DEV_TYPE_910A3},
47 : {"nosoc", DevType::DEV_TYPE_NOSOC}};
48 :
49 : // 添加编译宏，防止返回82类型芯片造成已有UT失效
50 58 : DevType HrtGetDeviceType()
51 : {
52 58 : std::string targetChipVerStr;
53 58 : HrtGetSocVer(targetChipVerStr);
54 :
55 174 : HCCL_INFO("[HrtGetDeviceType]targetChipVerStr = %s.", targetChipVerStr.c_str());
56 58 : if (targetChipVerStr.find("Ascend950") != std::string::npos) {
57 171 : HCCL_INFO("[HrtGetDeviceType]DeviceType = DevType::DEV_TYPE_950.");
58 57 : return DevType::DEV_TYPE_950;
59 : }
60 :
61 2 : if (targetChipVerStr.find("Ascend910_96") != std::string::npos ||
62 2 : targetChipVerStr.find("Ascend960") != std::string::npos ||
63 1 : targetChipVerStr.find("ascend960") != std::string::npos) {
64 0 : HCCL_INFO("[HrtGetDeviceType]DeviceType = DevType::DEV_TYPE_960.");
65 0 : return DevType::DEV_TYPE_960;
66 : }
67 :
68 1 : auto iter = SOC_VER_CONVERT.find(targetChipVerStr);
69 1 : if (iter == SOC_VER_CONVERT.end()) {
70 : string msg = StringFormat("[Get][DeviceType]errNo[0x%016llx] rtGetSocVersion get "
71 : "illegal chipver, chip_ver[%s].",
72 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), targetChipVerStr.c_str());
73 4 : MACRO_THROW(RuntimeApiException, msg);
74 1 : }
75 0 : return iter->second;
76 58 : }
77 :
78 357 : DevId HrtGetDevicePhyIdByIndex(s32 deviceLogicId)
79 : {
80 357 : DevType deviceType = HrtGetDeviceType();
81 357 : if (deviceType == DevType::DEV_TYPE_NOSOC) {
82 1 : return 0;
83 : }
84 :
85 356 : s32 devicePhyId = 0;
86 356 : aclError ret = aclrtGetPhyDevIdByLogicDevId(deviceLogicId, &devicePhyId);
87 356 : if (ret != ACL_SUCCESS) {
88 : string msg = StringFormat("[Get][DevicePhyId]errNo[0x%016llx] rtGet device PhyId by "
89 : "index failed. return[%d], "
90 : "para: devIndex[%d], phyId[%d].",
91 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_DRV), ret, deviceLogicId, devicePhyId);
92 4 : MACRO_THROW(RuntimeApiException, msg);
93 1 : }
94 1065 : HCCL_INFO("[HrtGetDevicePhyIdByIndex]deviceLogicId=%d, devicePhyId=%d.", deviceLogicId, devicePhyId);
95 355 : return static_cast<DevId>(devicePhyId);
96 : }
97 :
98 3 : s32 HrtDeviceGetBareTgid()
99 : {
100 3 : s32 pid = 0;
101 3 : aclError ret = aclrtDeviceGetBareTgid(&pid);
102 9 : HCCL_INFO("Call rtDeviceGetBareTgid, return value[%d], rtGet pid[%d].", ret, pid);
103 3 : if (ret != ACL_SUCCESS) {
104 : string msg = StringFormat("[Get][BareTgid]errNo[0x%016llx] rtGet pid fail. "
105 : "return[%d], rtGet pid[%d].",
106 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, pid);
107 4 : MACRO_THROW(RuntimeApiException, msg);
108 1 : }
109 2 : return pid;
110 : }
111 :
112 58 : void HrtGetSocVer(std::string &socName)
113 : {
114 58 : const char *socNamePtr = aclrtGetSocName();
115 58 : if (socNamePtr == nullptr) {
116 : string msg = StringFormat("[Get][SocVer]errNo[0x%016llx] rtGet deviceVer failed.",
117 1 : HCCL_ERROR_CODE((HcclResult::HCCL_E_RUNTIME)));
118 4 : MACRO_THROW(RuntimeApiException, msg);
119 1 : }
120 57 : socName = socNamePtr;
121 57 : }
122 :
123 1573 : s32 HrtGetDevice()
124 : {
125 1573 : s32 deviceLogicId = 0;
126 1573 : aclError ret = aclrtGetDevice(&deviceLogicId);
127 1573 : if (ret != ACL_SUCCESS) {
128 : string msg = StringFormat("[Get][Device]errNo[0x%016llx] rtGet device fail, "
129 : "please make sure that device is set. return[%d], para:deviceLogicId[%d]",
130 2 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, deviceLogicId);
131 8 : MACRO_THROW(RuntimeApiException, msg);
132 2 : }
133 4713 : HCCL_INFO("[HrtGetDevice]deviceLogicId=%d.", deviceLogicId);
134 1571 : return deviceLogicId;
135 : }
136 :
137 14 : void HrtSetDevice(s32 deviceLogicId)
138 : {
139 14 : aclError ret = aclrtSetDevice(deviceLogicId);
140 42 : HCCL_INFO("Call rtSetDevice, return value[%d], para: device_id[%d].", ret, deviceLogicId);
141 14 : if (ret != ACL_SUCCESS) {
142 : string msg = StringFormat("[Set][Device]errNo[0x%016llx] rtSet device fail. "
143 : "return[%d], para:deviceLogicId[%d].",
144 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, deviceLogicId);
145 4 : MACRO_THROW(RuntimeApiException, msg);
146 1 : }
147 13 : }
148 :
149 5 : void HrtResetDevice(s32 deviceLogicId)
150 : {
151 5 : aclError ret = aclrtResetDevice(deviceLogicId);
152 15 : HCCL_INFO("Call aclrtResetDevice, return value[%d], para: device_id[%d].", ret, deviceLogicId);
153 5 : if (ret != ACL_SUCCESS) {
154 : string msg = StringFormat("[Reset][Device]errNo[0x%016llx] rtReset device fail. "
155 : "return[%d], para: deviceLogicId[%d].",
156 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, deviceLogicId);
157 4 : MACRO_THROW(RuntimeApiException, msg);
158 1 : }
159 4 : }
160 :
161 2 : u32 HrtGetDeviceCount()
162 : {
163 2 : u32 count = 0;
164 2 : aclError ret = aclrtGetDeviceCount(&count);
165 6 : HCCL_INFO("Call rtGetDeviceCount, return value[%d], para: count[%u].", ret, count);
166 2 : if (ret != ACL_SUCCESS) {
167 : string msg = StringFormat("[Get][DeviceCount]errNo[0x%016llx] rtGet device count fail. "
168 : "return[%d], para:count[%u].",
169 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, count);
170 4 : MACRO_THROW(RuntimeApiException, msg);
171 1 : }
172 1 : return count;
173 : }
174 :
175 115 : HcclResult HrtGetLogicDevIdByUserDevId(s32 userDevId, s32 &logicDevId)
176 : {
177 115 : DevType deviceType = HrtGetDeviceType();
178 115 : if (deviceType == DevType::DEV_TYPE_NOSOC) {
179 0 : logicDevId = 0;
180 0 : return HCCL_SUCCESS;
181 : }
182 :
183 115 : aclError aclRet = aclrtGetLogicDevIdByUserDevId(userDevId, &logicDevId); // userDevId 转 logicDevId
184 115 : if (aclRet != ACL_SUCCESS) {
185 0 : HCCL_ERROR("aclrtGetLogicDevIdByUserDevId failed, userDevId: %d, ret: %d", userDevId, aclRet);
186 0 : return HCCL_E_RUNTIME;
187 : }
188 :
189 115 : return HCCL_SUCCESS;
190 : }
191 :
192 : constexpr char RTS_SO_NAME[] = "libruntime.so";
193 : DlRtsFunctionV2<RTS_SO_NAME> g_dlRts;
194 3 : HcclResult HrtResetXpuDevice(uint32_t devType, const uint32_t devId)
195 : {
196 3 : static auto funcPtr = reinterpret_cast<rtError_t(*)(uint32_t, const uint32_t)>(g_dlRts.Handle<RT_RESET_XPU_DEVICE>());
197 12 : CHK_PTR_NULL(funcPtr);
198 0 : rtError_t ret = funcPtr(devType, devId);
199 0 : if (ret != RT_ERROR_NONE) {
200 0 : HCCL_ERROR("[%s] reset xpu device failed, devType[%u], devId[%u], return[%d].", __func__, devType, devId, ret);
201 0 : return HCCL_E_RUNTIME;
202 : }
203 0 : return HCCL_SUCCESS;
204 : }
205 :
206 0 : HcclResult HrtSetXpuDevice(uint32_t devType, const uint32_t devId)
207 : {
208 0 : static auto funcPtr = reinterpret_cast<rtError_t(*)(uint32_t, const uint32_t)>(g_dlRts.Handle<RT_SET_XPU_DEVICE>());
209 0 : CHK_PTR_NULL(funcPtr);
210 0 : rtError_t ret = funcPtr(devType, devId);
211 0 : if (ret != RT_ERROR_NONE) {
212 0 : HCCL_ERROR("[%s] set xpu device failed, devType[%u], devId[%u], return[%d].", __func__, devType, devId, ret);
213 0 : return HCCL_E_RUNTIME;
214 : }
215 0 : return HCCL_SUCCESS;
216 : }
217 :
218 78 : s32 HrtGetStreamId(aclrtStream ptr)
219 : {
220 : s32 streamId;
221 78 : aclError ret = aclrtStreamGetId(ptr, &streamId);
222 234 : HCCL_INFO("Call aclrtStreamGetId, ptr[%p] return value[%d] streamId[%d].", ptr, ret, streamId);
223 78 : if (ret != ACL_SUCCESS) {
224 : string msg = StringFormat("[Get][StreamId]errNo[0x%016llx]. "
225 : "rt get stream ID fail. ptr[%p], return[%d].",
226 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ptr, ret);
227 4 : MACRO_THROW(RuntimeApiException, msg);
228 1 : }
229 :
230 77 : return streamId;
231 : }
232 :
233 16 : u64 HrtStreamGetMode(HcclRtStream const ptr)
234 : {
235 16 : if (ptr == nullptr) {
236 1 : throw RuntimeApiException(StringFormat("ptr is null, call aclrtGetStreamAttribute failed, ptr=%p", ptr));
237 : }
238 15 : u64 stmMode = 0;
239 15 : s32 streamId = -1;
240 15 : aclError ret = aclrtStreamGetId(ptr, &streamId);
241 45 : HCCL_DEBUG("[HrtStreamGetMode] ptr[%p], ret[%d].", ptr, ret);
242 : aclrtStreamAttrValue value;
243 15 : ret = aclrtGetStreamAttribute(ptr, ACL_STREAM_ATTR_FAILURE_MODE, &value);
244 15 : stmMode = value.failureMode;
245 45 : HCCL_INFO("Call rtStreamGetMode return value[%d]. stmMode[%llu].", ret, stmMode);
246 15 : if (ret != ACL_SUCCESS) {
247 : string msg = StringFormat("[Stream][GetMode]errNo[0x%016llx] rtStreamGetMode error. "
248 : "ptr[%p], stmMode[%llu], streamId[%d], rtRet[%d].",
249 0 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ptr, stmMode, streamId, ret);
250 0 : MACRO_THROW(RuntimeApiException, msg);
251 0 : }
252 15 : return static_cast<u64>(stmMode);
253 : }
254 :
255 118 : void HrtStreamSetMode(HcclRtStream streamPtr, const uint64_t stmMode)
256 : {
257 118 : if (streamPtr == nullptr) {
258 1 : throw RuntimeApiException(StringFormat("ptr is null, call aclrtSetStreamAttribute failed, ptr=%p", streamPtr));
259 : }
260 117 : s32 streamId = -1;
261 117 : aclError ret = aclrtStreamGetId(streamPtr, &streamId);
262 351 : HCCL_DEBUG("Call aclrtStreamGetId, return value[%d].", ret);
263 : aclrtStreamAttrValue value;
264 117 : value.failureMode = stmMode;
265 117 : ret = aclrtSetStreamAttribute(streamPtr, ACL_STREAM_ATTR_FAILURE_MODE, &value);
266 351 : HCCL_INFO("[HrtStreamSetMode]streamPtr[%p], stmMode[%llu], ret[%d].", streamPtr, stmMode, ret);
267 117 : if (ret != ACL_SUCCESS) {
268 : string msg = StringFormat("[Stream][SetMode]errNo[0x%016llx] rtStreamSetMode error. "
269 : "streamPtr[%p], rtRet[%d], stmMode[%llu].",
270 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), streamPtr, ret, stmMode);
271 4 : MACRO_THROW(RuntimeApiException, msg);
272 1 : }
273 116 : }
274 :
275 291 : HcclResult HrtGetDeviceInfo(uint32_t deviceLogicId, int32_t moduleType, aclrtDevAttr infoType, int64_t &val)
276 : {
277 291 : if(moduleType != DEV_MODULE_TYPE::MODULE_TYPE_SYSTEM)
278 : {
279 0 : THROW<NotSupportException>(StringFormat("[hrtGetDeviceInfo]Unsupported moduleType[%d].", moduleType));
280 : }
281 291 : aclError ret = aclrtGetDeviceInfo(deviceLogicId, infoType, reinterpret_cast<int64_t *>(&val));
282 873 : HCCL_INFO("[HrtGetDeviceInfo]deviceLogicId[%u], moduleType[%d], infoType[%d], return[%d], val[%lld].",
283 : deviceLogicId, moduleType, infoType, ret, val);
284 291 : if (ret != ACL_SUCCESS) {
285 0 : HCCL_ERROR("[HrtGetDeviceInfo]errNo[0x%016llx] rt get device info failed, "
286 : "deviceLogicId=%u, moduleType=%d, infoType=%d",
287 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), deviceLogicId, moduleType, infoType);
288 0 : return HcclResult::HCCL_E_RUNTIME;
289 : }
290 291 : return HcclResult::HCCL_SUCCESS;
291 : }
292 :
293 : constexpr uint64_t POD_MAINBOARD = 0x0;
294 : constexpr uint64_t A_K_SERVER_MAINBOARD = 0x1;
295 : constexpr uint64_t A_X_SERVER_MAINBOARD = 0x2;
296 : constexpr uint64_t PCIE_STD_MAINBOARD = 0x3;
297 : constexpr uint64_t RSV1_MAINBOARD = 0x4;
298 : constexpr uint64_t RSV2_MAINBOARD = 0x5;
299 : constexpr uint64_t EQUIP_MAINBOARD = 0x6;
300 : constexpr uint64_t EVB_MAINBOARD = 0x7;
301 :
302 : const std::unordered_map<uint64_t, HcclMainboardId> rtMainboardIdToHcclMainboardId = {
303 : {POD_MAINBOARD, HcclMainboardId::MAINBOARD_POD},
304 : {A_K_SERVER_MAINBOARD, HcclMainboardId::MAINBOARD_A_K_SERVER},
305 : {A_X_SERVER_MAINBOARD, HcclMainboardId::MAINBOARD_A_X_SERVER},
306 : {PCIE_STD_MAINBOARD, HcclMainboardId::MAINBOARD_PCIE_STD},
307 : {RSV1_MAINBOARD, HcclMainboardId::MAINBOARD_RSV},
308 : {RSV2_MAINBOARD, HcclMainboardId::MAINBOARD_RSV},
309 : {EQUIP_MAINBOARD, HcclMainboardId::MAINBOARD_EQUIPMENT},
310 : {EVB_MAINBOARD, HcclMainboardId::MAINBOARD_EVB}
311 : };
312 :
313 : /*
314 : * 获取Mainboard ID 5-7位，输出整机形态枚举值
315 : * Mainboard ID描述说明
316 : * Mainboard ID采用了16bit，区分形态，主从，以及端口配置
317 : * bit[7:5] 区分整机形态(当前POD和EVB没有区分A+X或A+K)
318 : * {
319 : * 000: 天成 POD
320 : * 001: A+K Server
321 : * 010: A+X Server
322 : * 011: PCIE标卡
323 : * 100-101: RSV
324 : * 110: 装备
325 : * 111: EVB
326 : * }
327 : * bit[4:1] 整机形态细分
328 : * {
329 : * 0000-1111
330 : * }
331 : * bit[0] 主从或池化
332 : * {
333 : * 0: 主从（NPU作为某个Host的从设备，Host主控）
334 : * 1: 池化（NPU作为资源池，其它Host对等访问）
335 : * }
336 : */
337 291 : HcclResult HrtGetMainboardId(uint32_t deviceLogicId, HcclMainboardId &hcclMainboardId)
338 : {
339 291 : constexpr int32_t moduleType = DEV_MODULE_TYPE::MODULE_TYPE_SYSTEM;
340 291 : constexpr aclrtDevAttr infoType = aclrtDevAttr::ACL_DEV_ATTR_MAINBOARD_ID;
341 291 : constexpr uint64_t BITS_5 = 5;
342 291 : constexpr uint64_t MASK_7 = 0x7;
343 291 : int64_t val = 0;
344 291 : CHK_RET(HrtGetDeviceInfo(deviceLogicId, moduleType, infoType, val));
345 873 : HCCL_INFO("[HrtGetMainboardId] deviceLogicId[%u] val[%lld].", deviceLogicId, val);
346 291 : CHK_PRT_RET(val < 0, HCCL_ERROR("[HrtGetMainboardId]val[%lld] < 0", val), HCCL_E_RUNTIME);
347 291 : uint64_t mainboardId = (static_cast<uint64_t>(val) >> BITS_5) & MASK_7; // 提取val的5-7位，判断整机形态
348 291 : auto it = rtMainboardIdToHcclMainboardId.find(mainboardId);
349 291 : if (it != rtMainboardIdToHcclMainboardId.end()) {
350 291 : hcclMainboardId = it->second;
351 : } else {
352 0 : hcclMainboardId = HcclMainboardId::MAINBOARD_OTHERS;
353 : }
354 873 : HCCL_INFO("[HrtGetMainboardId] deviceLogicId[%u] mainboardId[%llu] hcclMainboardId[%s].",
355 : deviceLogicId, mainboardId, hcclMainboardId.Describe().c_str());
356 291 : return HcclResult::HCCL_SUCCESS;
357 : }
358 :
359 104 : aclrtStream HrtStreamCreateWithFlags(uint32_t priority, uint32_t flag)
360 : {
361 104 : aclrtStream ptr = nullptr;
362 104 : aclError ret = aclrtCreateStreamWithConfig(&ptr, priority, flag);
363 312 : HCCL_INFO("[HrtStreamCreateWithFlags] priority[%u], flags[%u], ptr[%p], ret[%d].", priority, flag, ptr, ret);
364 :
365 104 : if (ret != ACL_SUCCESS) {
366 : string msg = StringFormat("[Stream][CreateWithFlags]errNo[0x%016llx] rtStreamCreate error, "
367 : "rtRet[%d], flags[%u].",
368 0 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, flag);
369 0 : MACRO_THROW(RuntimeApiException, msg);
370 0 : }
371 :
372 104 : return ptr;
373 : }
374 :
375 99 : void HrtStreamDestroy(aclrtStream ptr)
376 : {
377 99 : aclError ret = aclrtDestroyStreamForce(ptr);
378 297 : HCCL_INFO("[HrtStreamDestroy] ptr[%p], ret[%d].", ptr, ret);
379 99 : if (ret != ACL_SUCCESS) {
380 : string msg = StringFormat("[Stream][Destroy]errNo[0x%016llx] rt stream Destroy fail. "
381 : "return[%d], ptr[%p].",
382 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, ptr);
383 4 : MACRO_THROW(RuntimeApiException, msg);
384 1 : }
385 98 : }
386 :
387 2 : void HrtStreamActive(aclrtStream activeStream, aclrtStream stream)
388 : {
389 2 : aclError ret = aclrtActiveStream(activeStream, stream);
390 6 : HCCL_INFO("[HrtStreamActive] activeStream[%p], stream[%p], ret[%d].", activeStream, stream, ret);
391 2 : if (ret != ACL_SUCCESS) {
392 : string msg = StringFormat("[Activate][Stream]errNo[0x%016llx] "
393 : "rt stream active fail. return[%d], active_stream=%p, stream=%p.",
394 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, activeStream, stream);
395 4 : MACRO_THROW(RuntimeApiException, msg);
396 1 : }
397 1 : }
398 :
399 1 : inline s32 GetMsTimeFromExecTimeout()
400 : {
401 1 : constexpr s32 HCCL_EXEC_TIME_OUT_OFFSET_S = 5; // 避免与notifywait timeout时间冲突，增加5s的偏移值
402 1 : constexpr u32 TIME_S_TO_MS = 1000;
403 1 : s32 execTimeOut = 3000; // 从环境变量中获取超时时间
404 1 : s64 timeOutMs = (execTimeOut + HCCL_EXEC_TIME_OUT_OFFSET_S) * TIME_S_TO_MS;
405 1 : timeOutMs = (timeOutMs > 0x7FFFFFFF) ? 0x7FFFFFFF : timeOutMs;
406 1 : return static_cast<s32>(static_cast<u64>(timeOutMs) & (0x7FFFFFFF));
407 : }
408 :
409 2 : void HcclStreamSynchronize(HcclRtStream ptr)
410 : {
411 2 : if (ptr == nullptr) {
412 1 : string msg = StringFormat("ptr is null, call aclrtSynchronizeStreamWithTimeout failed, ptr=%p", ptr);
413 4 : MACRO_THROW(RuntimeApiException, msg);
414 1 : }
415 3 : HCCL_INFO("[HcclStreamSynchronize] ptr[%p].", ptr);
416 1 : s32 timeout = GetMsTimeFromExecTimeout();
417 1 : aclError ret = aclrtSynchronizeStreamWithTimeout(ptr, timeout);
418 1 : if (ret != ACL_SUCCESS) {
419 : string msg = StringFormat("[Synchronize][Stream]errNo[0x%016llx] rt "
420 : "streamsynchronizewithtimeout fail. return[%d], stream[%p], timeout[%d].",
421 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, ptr, timeout);
422 4 : MACRO_THROW(RuntimeApiException, msg);
423 1 : }
424 0 : }
425 :
426 : /*
427 : *RT_MEMORY_TS：aclrtMallocForTaskScheduler
428 : *RT_MEMORY_DDR：ACL_MEM_TYPE_LOW_BAND_WIDTH
429 : *RT_MEMORY_HBM：ACL_MEM_TYPE_HIGH_BAND_WIDTH
430 : */
431 754 : void *HrtMalloc(u64 size, aclrtMemType_t memType)
432 : {
433 754 : aclError ret = ACL_SUCCESS;
434 754 : void *devPtr = nullptr;
435 : aclrtMallocAttrValue moduleIdValue;
436 754 : moduleIdValue.moduleId = HCCL;
437 754 : aclrtMallocAttribute attrs{.attr = ACL_RT_MEM_ATTR_MODULE_ID, .value = moduleIdValue};
438 754 : aclrtMallocConfig cfg{.attrs = &attrs, .numAttrs = 1};
439 754 : ret = aclrtMallocWithCfg(&devPtr, size, static_cast<aclrtMemMallocPolicy>(memType), &cfg);
440 2262 : HCCL_INFO("[HrtMalloc] ret[%d] size[%llu], memType[%d], devPtr[%p], moudleId: HCCL.",
441 : ret, size, memType, devPtr);
442 754 : if (ret == ACL_ERROR_RT_MEMORY_ALLOCATION) {
443 0 : RPT_INPUT_ERR(true, "EI0007", std::vector<std::string>({"resource_type", "resource_info"}),
444 : std::vector<std::string>({"DeviceMemory", std::string("MallocWithCfg, size:") + std::to_string(size) + " bytes"}));
445 : string msg = StringFormat("[Malloc][Mem]errNo[0x%016llx] aclrtMallocWithCfg failed, "
446 : "Reason: out of memory, return[%d], para: devPtrAddr[%p], size[%llu]",
447 0 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, devPtr, size);
448 0 : MACRO_THROW(RuntimeApiException, msg);
449 0 : }
450 754 : if (ret != ACL_SUCCESS) {
451 1 : RPT_INPUT_ERR(true, "EI0007", std::vector<std::string>({"resource_type", "resource_info"}),
452 : std::vector<std::string>({"DeviceMemory", std::string("MallocWithCfg, size:") + std::to_string(size)+ " bytes"}));
453 : string msg = StringFormat("[Malloc][Mem]errNo[0x%016llx] aclrtMallocWithCfg failed, "
454 : "return[%d], para: devPtrAddr[%p], size[%llu]",
455 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, devPtr, size);
456 4 : MACRO_THROW(RuntimeApiException, msg);
457 1 : }
458 753 : return devPtr;
459 0 : }
460 :
461 1062 : void HrtFree(void *devPtr)
462 : {
463 1062 : aclError ret = aclrtFree(devPtr);
464 3186 : HCCL_INFO("[HrtFree] ret[%d], para: dev_ptr[%p].", ret, devPtr);
465 1062 : if (ret != RT_ERROR_NONE) {
466 : string msg = StringFormat("[Free][Mem]errNo[0x%016llx] aclrtFree failed. "
467 : "return[%d], para: devPtrAddr[%p].",
468 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, devPtr);
469 4 : MACRO_THROW(RuntimeApiException, msg);
470 1 : }
471 1061 : }
472 :
473 1939 : HcclResult MemcpyKindTranslate(rtMemcpyKind_t kind, aclrtMemcpyKind *rtKind)
474 : {
475 1939 : switch (kind) {
476 5 : case rtMemcpyKind_t::RT_MEMCPY_HOST_TO_HOST: {
477 5 : *rtKind = ACL_MEMCPY_HOST_TO_HOST;
478 5 : return HCCL_SUCCESS;
479 : }
480 1190 : case rtMemcpyKind_t::RT_MEMCPY_HOST_TO_DEVICE: {
481 1190 : *rtKind = ACL_MEMCPY_HOST_TO_DEVICE;
482 1190 : return HCCL_SUCCESS;
483 : }
484 742 : case rtMemcpyKind_t::RT_MEMCPY_DEVICE_TO_HOST: {
485 742 : *rtKind = ACL_MEMCPY_DEVICE_TO_HOST;
486 742 : return HCCL_SUCCESS;
487 : }
488 1 : case rtMemcpyKind_t::RT_MEMCPY_DEVICE_TO_DEVICE: {
489 1 : *rtKind = ACL_MEMCPY_DEVICE_TO_DEVICE;
490 1 : return HCCL_SUCCESS;
491 : }
492 1 : default: {
493 3 : HCCL_ERROR("[MemcpyKindTranslate]Not support the memory copy type[%d].", kind);
494 1 : return HCCL_E_PARA;
495 : }
496 : }
497 : }
498 :
499 1939 : void HrtMemcpy(void *dst, uint64_t destMax, const void *src, uint64_t count, rtMemcpyKind_t kind)
500 : {
501 1939 : aclmdlRICaptureMode mode = aclmdlRICaptureMode::ACL_MODEL_RI_CAPTURE_MODE_RELAXED;
502 1939 : HcclResult hcclRet = HrtThreadExchangeCaptureMode(&mode);
503 1939 : CHK_PRT_CONT(hcclRet != HCCL_SUCCESS && hcclRet != HCCL_E_NOT_SUPPORT,
504 : HCCL_WARNING("[hrtMemcpy] HrtThreadExchangeCaptureMode return [%d].", hcclRet));
505 1939 : aclrtMemcpyKind rtKind = ACL_MEMCPY_DEFAULT;
506 1939 : hcclRet = MemcpyKindTranslate(kind, &rtKind);
507 1939 : aclError ret = aclrtMemcpy(dst, destMax, src, count, rtKind);
508 5817 : HCCL_INFO("[HrtMemcpy] dst[%p], destMax[%llu], src[%p], count[%llu], ret[%d].",
509 : dst, destMax, src, count, ret);
510 1939 : if (ret != ACL_SUCCESS) {
511 : string msg = StringFormat("[SyncCopy][Mem]errNo[0x%016llx] rtMemcpy failed. "
512 : "return[%d], para: dstAddr[%p], destMax[%llu], srcAddr[%p], count[%llu], kind[%d].",
513 4 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, dst, destMax, src, count, kind);
514 16 : MACRO_THROW(RuntimeApiException, msg);
515 4 : }
516 1935 : hcclRet = HrtThreadExchangeCaptureMode(&mode);
517 1935 : CHK_PRT_CONT(hcclRet != HCCL_SUCCESS && hcclRet != HCCL_E_NOT_SUPPORT,
518 : HCCL_WARNING("[hrtMemcpy] HrtThreadExchangeCaptureMode return [%d].", hcclRet));
519 1935 : }
520 :
521 249 : void HrtMemset(void *dst, uint64_t destMax, uint64_t count)
522 : {
523 747 : HCCL_INFO("[HrtMemset] dst[%p], destMax[%llu], count[%llu].", dst, destMax, count);
524 249 : aclmdlRICaptureMode mode = aclmdlRICaptureMode::ACL_MODEL_RI_CAPTURE_MODE_RELAXED;
525 249 : HcclResult hcclRet = HrtThreadExchangeCaptureMode(&mode);
526 249 : CHK_PRT_CONT(hcclRet != HCCL_SUCCESS && hcclRet != HCCL_E_NOT_SUPPORT,
527 : HCCL_WARNING("[hrtMemSet] HrtThreadExchangeCaptureMode return [%d].", hcclRet));
528 249 : aclError ret = aclrtMemset(dst, destMax, 0, count);
529 249 : if (ret != ACL_SUCCESS) {
530 : string msg = StringFormat("[SyncSet][Mem]errNo[0x%016llx] aclrtMemset failed. "
531 : "return[%d], para: dstAddr[%p], destMax[%llu], count[%llu].",
532 0 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, dst, destMax, count);
533 0 : MACRO_THROW(RuntimeApiException, msg);
534 0 : }
535 249 : hcclRet = HrtThreadExchangeCaptureMode(&mode);
536 249 : CHK_PRT_CONT(hcclRet != HCCL_SUCCESS && hcclRet != HCCL_E_NOT_SUPPORT,
537 : HCCL_WARNING("[hrtMemSet] HrtThreadExchangeCaptureMode return [%d].", hcclRet));
538 249 : }
539 :
540 0 : void HrtMemsetV2(void *dst, size_t destMax, int32_t value, size_t count) {
541 0 : aclmdlRICaptureMode mode = aclmdlRICaptureMode::ACL_MODEL_RI_CAPTURE_MODE_RELAXED;
542 0 : HcclResult hcclRet = HrtThreadExchangeCaptureMode(&mode);
543 0 : CHK_PRT_CONT(hcclRet != HCCL_SUCCESS && hcclRet != HCCL_E_NOT_SUPPORT,
544 : HCCL_WARNING("[HrtMemsetV2] HrtThreadExchangeCaptureMode return [%d]", hcclRet));
545 0 : aclError ret = aclrtMemset(dst, destMax, value, count);
546 :
547 0 : HCCL_INFO("Call aclrtMemset, return value[%d]", ret);
548 0 : if (ret != ACL_SUCCESS) {
549 0 : HCCL_ERROR("[HrtMemsetV2]errNo[0x%016llx] aclrtMemset failed, "
550 : "return[%d], para: dstAddr[%p], value[%d], count[%zu].",
551 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, dst, value, count);
552 0 : throw RuntimeApiException(StringFormat(
553 0 : "call aclrtMemset failed, dst=%p, value=0x%x, count=0x%zx", dst, value, count));
554 : }
555 0 : hcclRet = HrtThreadExchangeCaptureMode(&mode);
556 0 : CHK_PRT_CONT(hcclRet != HCCL_SUCCESS && hcclRet != HCCL_E_NOT_SUPPORT,
557 : HCCL_WARNING("[hrtMemSet] HrtThreadExchangeCaptureMode return [%d]", hcclRet));
558 0 : }
559 :
560 6 : void HrtIpcSetMemoryName(void *ptr, char_t *name, u64 ptrMaxLen, u32 nameMaxLen)
561 : {
562 6 : aclError ret = aclrtIpcMemGetExportKey(ptr, ptrMaxLen, name, nameMaxLen, 1UL);
563 18 : HCCL_INFO("Call aclrtIpcMemGetExportKey, return value[%d], para: ptr[%p], name[%s], byteCount[%llu], nameLen[%u]",
564 : ret, ptr, name, ptrMaxLen, nameMaxLen);
565 6 : if (ret != ACL_SUCCESS) {
566 : string msg = StringFormat("[Set][IpcMemoryName]errNo[0x%016llx] rtSet Ipc Memory Name. "
567 : "return[%d], para: ptr[%p], byteCount[%llu], name[%s].",
568 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, ptr, ptrMaxLen, name);
569 4 : MACRO_THROW(RuntimeApiException, msg);
570 1 : }
571 5 : }
572 :
573 6 : void HrtIpcDestroyMemoryName(const char_t *name)
574 : {
575 6 : aclError ret = aclrtIpcMemClose(reinterpret_cast<const char *>(name));
576 18 : HCCL_INFO("Call aclrtIpcMemClose, return[%d], para: name[%s]", ret, reinterpret_cast<const char *>(name));
577 6 : if (ret != ACL_SUCCESS) {
578 : string msg = StringFormat("[Destroy][IpcMemoryName]errNo[0x%016llx] "
579 : "rtDestroy Ipc memory name fail. return[%d], para: name[%s].",
580 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, name);
581 4 : MACRO_THROW(RuntimeApiException, msg);
582 1 : }
583 5 : }
584 :
585 3 : void *HrtIpcOpenMemory(const char_t *name)
586 : {
587 9 : HCCL_INFO("[HrtIpcOpenMemory] name[%s].", name);
588 3 : void *ptr = nullptr;
589 3 : aclError ret = aclrtIpcMemImportByKey(&ptr, name, 0UL);
590 3 : if (ret != ACL_SUCCESS) {
591 : string msg = StringFormat("[Open][IpcMemory]errNo[0x%016llx] "
592 : "rtOpen ipc memory fail. return[%d], para: ptr[%p], name[%s].",
593 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, ptr, name);
594 4 : MACRO_THROW(RuntimeApiException, msg);
595 1 : }
596 2 : return ptr;
597 : }
598 :
599 2 : void HrtIpcCloseMemory(const void *ptr)
600 : {
601 2 : aclError ret = aclrtIpcMemClose(reinterpret_cast<const char *>(ptr));
602 6 : HCCL_INFO("Call aclrtIpcMemClose, return[%d], para: name[%s].", ret, reinterpret_cast<const char *>(ptr));
603 2 : if (ret != ACL_SUCCESS) {
604 : string msg = StringFormat("[Close][IpcMemory]errNo[0x%016llx] "
605 : "rtClose ipc memory failed. return[%d], para: ptr[%p].",
606 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, ptr);
607 4 : MACRO_THROW(RuntimeApiException, msg);
608 1 : }
609 1 : }
610 :
611 1 : void HrtIpcSetMemoryPid(const char_t *name, int pid)
612 : {
613 1 : aclError ret = aclrtIpcMemSetImportPid(name, &pid, 1);
614 3 : HCCL_INFO("Call aclrtIpcMemSetImportPid, return value[%d], pid[%d], name[%s].", ret, pid, name);
615 1 : if (ret != ACL_SUCCESS) {
616 : string msg = StringFormat("[Set][IpcMemoryPid]errNo[0x%016llx] "
617 : "rtSet ipc memory pid fail. return[%d], pid[%d], name[%s].",
618 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, pid, name);
619 4 : MACRO_THROW(RuntimeApiException, msg);
620 1 : }
621 0 : }
622 :
623 8 : aclrtPtrAttributes HrtPointerGetAttributes(const void *ptr)
624 : {
625 24 : HCCL_INFO("[HrtPointerGetAttributes] ptr[%p].", ptr);
626 : aclrtPtrAttributes ptrAttr;
627 8 : aclError ret = aclrtPointerGetAttributes(ptr, reinterpret_cast<aclrtPtrAttributes *>(&ptrAttr));
628 8 : if (ret != ACL_SUCCESS) {
629 : string msg = StringFormat("[Get][PointAttr]errNo[0x%016llx] rt get point attr failed, "
630 : "return[%d], para: ptrAddr[%p].",
631 2 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, ptr);
632 8 : MACRO_THROW(RuntimeApiException, msg);
633 2 : }
634 6 : return ptrAttr;
635 : }
636 :
637 1 : void PrintMemoryAttr(const void *memAddr)
638 : {
639 1 : if (LIKELY(!CheckInfoLogLevel())) {
640 0 : return;
641 : }
642 1 : aclrtPtrAttributes memAttr = HrtPointerGetAttributes(memAddr);
643 3 : HCCL_INFO("[PrintMemoryAttr] address[%p], page size[%u], type[%d]", memAddr, memAttr.pageSize,
644 : memAttr.location.type);
645 : }
646 :
647 8 : void HrtDevMemAlignWithPage(void *ptr, u64 size, void *&ipcPtr, u64 &ipcSize, u64 &ipcOff)
648 : {
649 8 : aclrtPtrAttributes memAttr = HrtPointerGetAttributes(ptr);
650 :
651 21 : HCCL_INFO("[HrtDevMemAlignWithPage] ptr[%p], size[%llu], ipcPtr[%p], ipcSize[%llu], ipcOff[%llu], pageSize[%u].",
652 : ptr, size, ipcPtr, ipcSize, ipcOff, memAttr.pageSize);
653 7 : if (memAttr.pageSize == 0) {
654 1 : ipcPtr = ptr;
655 1 : ipcSize = size;
656 1 : ipcOff = 0;
657 1 : return;
658 : }
659 :
660 6 : u64 tmpPtr = reinterpret_cast<u64>(ptr);
661 6 : ipcPtr = reinterpret_cast<void *>((reinterpret_cast<u64>(ptr)) & (~(static_cast<u64>(memAttr.pageSize) - 1)));
662 6 : ipcOff = tmpPtr - reinterpret_cast<u64>(ipcPtr);
663 6 : ipcSize = size + ipcOff;
664 : }
665 :
666 141 : void *HrtMallocHost(u64 size)
667 : {
668 141 : void *hostPtr = nullptr;
669 : aclrtMallocAttrValue moduleIdValue;
670 141 : moduleIdValue.moduleId = HCCL;
671 141 : aclrtMallocAttribute attrs{.attr = ACL_RT_MEM_ATTR_MODULE_ID, .value = moduleIdValue};
672 141 : aclrtMallocConfig cfg{.attrs = &attrs, .numAttrs = 1};
673 141 : aclError ret = aclrtMallocHostWithCfg(&hostPtr, size, &cfg);
674 423 : HCCL_INFO("Call aclrtMallocHostWithCfg. return value[%d], para: hostPtr[%p], size[%llu], moudleId: HCCL.",
675 : ret, hostPtr, size);
676 141 : if (ret != ACL_SUCCESS) {
677 2 : RPT_INPUT_ERR(true, "EI0007", std::vector<std::string>({"resource_type", "resource_info"}),
678 : std::vector<std::string>({"HostMemory", std::string("MallocHostWithCfg, size:") + std::to_string(size)+ " bytes"}));
679 : string msg = StringFormat("[Malloc][Host]errNo[0x%016llx] rt malloc host fail. return[%d], "
680 : "para: size[%llu].",
681 2 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, size);
682 8 : MACRO_THROW(RuntimeApiException, msg);
683 2 : }
684 139 : return hostPtr;
685 0 : }
686 :
687 182 : void HrtFreeHost(void *hostPtr)
688 : {
689 546 : HCCL_INFO("[HrtFreeHost] hostPtr[%p].", hostPtr);
690 182 : aclError ret = aclrtFreeHost(hostPtr);
691 182 : if (ret != ACL_SUCCESS) {
692 : string msg = StringFormat("[Free][Host]errNo[0x%016llx] rt free host fail. return[%d], "
693 : "para: hostPtr[%p].",
694 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, hostPtr);
695 4 : MACRO_THROW(RuntimeApiException, msg);
696 1 : }
697 181 : }
698 :
699 120 : aclrtNotify HrtNotifyCreate(s32 deviceLogicId)
700 : {
701 120 : aclrtNotify ptr = nullptr;
702 : // aclrtCreateNotify 中通过 aclrtGetDevice 获取 deviceId，所以要求当前线程设置过 setDevice
703 120 : aclError ret = aclrtCreateNotify(&ptr, ACL_NOTIFY_DEFAULT);
704 120 : if (ret != ACL_SUCCESS) {
705 : string msg = StringFormat("[Notify][Create]errNo[0x%016llx] rtNotifyCreate error. "
706 : "return[%d], deviceId[%d], ptr[%p].",
707 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, deviceLogicId, ptr);
708 4 : MACRO_THROW(RuntimeApiException, msg);
709 1 : }
710 357 : HCCL_INFO("[HrtNotifyCreate] deviceId[%d], ptr[%p].", deviceLogicId, ptr);
711 119 : return ptr;
712 : }
713 :
714 865 : void HrtNotifyDestroy(RtNotify_t ptr)
715 : {
716 2595 : HCCL_INFO("[HrtNotifyDestroy] ptr[%p].", ptr);
717 865 : aclError ret = aclrtDestroyNotify(ptr);
718 865 : if (ret != ACL_SUCCESS) {
719 : string msg = StringFormat("[Notify][Destroy]errNo[0x%016llx] aclrtDestroyNotify error. "
720 : "ptr[%p], return[%d].",
721 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ptr, ret);
722 4 : MACRO_THROW(RuntimeApiException, msg);
723 1 : }
724 864 : }
725 :
726 2 : void HrtIpcSetNotifyName(RtNotify_t ptr, char_t *name, uint32_t len)
727 : {
728 2 : aclError ret = aclrtNotifyGetExportKey(ptr, name, len, 2UL);
729 6 : HCCL_INFO("[HrtIpcSetNotifyName] ptr[%p], name[%s], len[%u], ret[%d].", ptr, name, len, ret);
730 2 : if (ret != ACL_SUCCESS) {
731 : string msg = StringFormat("[Set][IPCNotify]errNo[0x%016llx] IPC set notify name fail. "
732 : "ptr[%p], name[%s], len[%u], return[%d].",
733 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ptr, name, len, ret);
734 4 : MACRO_THROW(RuntimeApiException, msg);
735 1 : }
736 1 : }
737 :
738 120 : u32 HrtGetNotifyID(RtNotify_t notifyHandle)
739 : {
740 120 : u32 notifyID = 0;
741 120 : aclError ret = aclrtGetNotifyId(notifyHandle, ¬ifyID);
742 120 : if (ret != ACL_SUCCESS) {
743 : string msg = StringFormat("[HrtGetNotifyID]rt get notify id failed. "
744 : "notifyHandle[%p], notifyID[%u], return[%d].",
745 1 : notifyHandle, notifyID, ret);
746 4 : MACRO_THROW(RuntimeApiException, msg);
747 1 : }
748 357 : HCCL_INFO("[HrtGetNotifyID] notifyHandle[%p], notifyID[%u].", notifyHandle, notifyID);
749 119 : return notifyID;
750 : }
751 :
752 2 : u64 HrtNotifyGetAddr(RtNotify_t notifyHandle)
753 : {
754 6 : HCCL_INFO("[HrtNotifyGetAddr] notifyHandle[%p].", notifyHandle);
755 : uint64_t addr;
756 2 : rtError_t ret = rtGetNotifyAddress(notifyHandle, &addr);
757 2 : if (ret != RT_ERROR_NONE) {
758 : string msg = StringFormat("[rtGetNotifyAddress]rt get notify address failed. "
759 : "notifyHandle[%p], addr[%llu], return[%d].",
760 1 : notifyHandle, addr, ret);
761 4 : MACRO_THROW(RuntimeApiException, msg);
762 1 : }
763 1 : return addr;
764 : }
765 :
766 1 : void HrtSetIpcNotifyPid(aclrtNotify notify, int32_t pid)
767 : {
768 1 : aclError ret = aclrtNotifySetImportPid(notify, &pid, 1);
769 3 : HCCL_INFO("[HrtSetIpcNotifyPid] notify[%p], pid[%d], ret[%d].", notify, pid, ret);
770 1 : if (ret != ACL_SUCCESS) {
771 : string msg = StringFormat("[Set][IpcNotifyPid]errNo[0x%016llx] "
772 : "rtSet ipc Notify pid fail. notify[%p], return[%d], pid[%d].",
773 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), notify, ret, pid);
774 4 : MACRO_THROW(RuntimeApiException, msg);
775 1 : }
776 0 : }
777 :
778 2 : RtNotify_t HrtIpcOpenNotify(const char_t *name)
779 : {
780 2 : uint64_t flags = 0;
781 2 : aclrtNotify* notify = nullptr;
782 2 : aclError ret = aclrtNotifyImportByKey(notify, name, static_cast<uint64_t>(flags));
783 6 : HCCL_INFO("[HrtIpcOpenNotify] ret[%d], para: notify[%p], name[%s].", ret, notify, name);
784 2 : if (ret != ACL_SUCCESS) {
785 : string msg = StringFormat("[rt][IpcOpenNotify]errNo[0x%016llx] rt ipc notify open fail. "
786 : "return[%d]. para: notify[%p], name[%s], flags[%llu].",
787 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, notify, name, flags);
788 4 : MACRO_THROW(RuntimeApiException, msg);
789 1 : }
790 1 : return notify;
791 : }
792 :
793 2 : u32 HrtNotifyGetOffset(RtNotify_t ptr)
794 : {
795 2 : uint32_t offset = 0;
796 2 : aclError ret = aclrtGetNotifyId(ptr, &offset);
797 2 : if (ret != ACL_SUCCESS) {
798 : string msg = StringFormat("[rt][NotifyGetOffset]errNo[0x%016llx] rt ipc notify open fail. "
799 : "return[%d], ptr[%p], offset[%u].",
800 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, ptr, offset);
801 4 : MACRO_THROW(RuntimeApiException, msg);
802 1 : }
803 3 : HCCL_INFO("[HrtNotifyGetOffset] ptr[%p], offset[%u].", ptr, offset);
804 1 : return offset;
805 : }
806 :
807 13 : void HrtNotifyWaitWithTimeOut(RtNotify_t notifyPtr, aclrtStream streamPtr, uint32_t timeOut)
808 : {
809 13 : aclError ret = aclrtWaitAndResetNotify(notifyPtr, streamPtr, timeOut);
810 39 : HCCL_INFO("[HrtNotifyWaitWithTimeOut] notifyPtr[%p], streamPtr[%p], timeOut[%u], ret[%d].",
811 : notifyPtr, streamPtr, timeOut, ret);
812 13 : if (ret != ACL_SUCCESS) {
813 : string msg = StringFormat("call aclrtWaitAndResetNotify failed. notifyPtr=%p, streamPtr=%p, timeout=%u, return=%d.",
814 1 : notifyPtr, streamPtr, timeOut, ret);
815 4 : MACRO_THROW(RuntimeApiException, msg);
816 1 : }
817 12 : }
818 :
819 11 : void HrtNotifyRecord(RtNotify_t notifyPtr, aclrtStream streamPtr)
820 : {
821 11 : aclError ret = aclrtRecordNotify(notifyPtr, streamPtr);
822 33 : HCCL_INFO("[HrtNotifyRecord] notifyPtr[%p], streamPtr[%p], ret[%d].", notifyPtr, streamPtr, ret);
823 11 : if (ret != ACL_SUCCESS) {
824 1 : string msg = StringFormat("call HrtNotifyRecord failed. notifyPtr=%p, streamPtr=%p, return=%d.", notifyPtr, streamPtr, ret);
825 4 : MACRO_THROW(RuntimeApiException, msg);
826 1 : }
827 10 : }
828 :
829 1 : void HrtMemAsyncCopy(void *dst, uint64_t destMax, const void *src, uint64_t count, aclrtMemcpyKind kind,
830 : aclrtStream streamPtr)
831 : {
832 1 : aclError ret = aclrtMemcpyAsync(dst, destMax, src, count, kind, streamPtr);
833 3 : HCCL_DEBUG("[HrtMemAsyncCopy] ret[%d], para: dstAddr[%p], destMax[%llu], "
834 : "srcAddr[%p], count[%llu], rtKind[%d], streamPtr[%p].", ret, dst, destMax, src, count, kind, streamPtr);
835 1 : if (ret != ACL_SUCCESS) {
836 : string msg = StringFormat("[AsyncCopy][Mem]errNo[0x%016llx] rt memory async copy failed. "
837 : "return[%d], para: dstAddr[%p], destMax[%llu], srcAddr[%p], count[%llu], kind[%d], stream[%p].",
838 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, dst, destMax, src, count, kind, streamPtr);
839 4 : MACRO_THROW(RuntimeApiException, msg);
840 1 : }
841 0 : }
842 :
843 4 : void HrtReduceAsync(void *dst, uint64_t destMax, const void *src, uint64_t count, aclrtReduceKind kind,
844 : aclDataType type, aclrtStream streamPtr)
845 : {
846 : // reserve 预留字段填 nullptr
847 4 : aclError ret = aclrtReduceAsync(dst, src, count, kind, type, streamPtr, nullptr);
848 12 : HCCL_INFO("Call rtReduceAsync, return value[%d], para: dst[%p], destMax[%llu], src[%p], count[%llu], rtReduceOp[%d], "
849 : "rtDataType[%d], streamPtr[%p].",
850 : ret, dst, destMax, src, count, kind, type, streamPtr);
851 4 : if (ret != ACL_SUCCESS) {
852 : string msg = StringFormat("[rt][ReduceAsync]errNo[0x%016llx] rt reduce async fail. "
853 : "return[%d], para: dst[%p], destMax[%llu], src[%p], count[%llu], rtReduceOp[%d], rtDataType[%d], streamPtr[%p].",
854 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, dst, destMax, src, count, kind, type, streamPtr);
855 4 : MACRO_THROW(RuntimeApiException, msg);
856 1 : }
857 3 : }
858 :
859 1 : void HrtRDMASend(u32 qpn, u32 wqeIndex, aclrtStream streamPtr)
860 : {
861 1 : rtError_t ret = rtRDMASend(qpn, wqeIndex, streamPtr);
862 3 : HCCL_INFO("Call rtRDMASend, return value[%d]. Params: qpn[%u], wqeIndex[%u], streamPtr[%p].", ret, qpn, wqeIndex, streamPtr);
863 1 : if (ret != RT_ERROR_NONE) {
864 : string msg = StringFormat("[rt][RdmaSend]errNo[0x%016llx] rt rdma send fail. "
865 : "return[%d]. para: qpn[%u], wqeIndex[%u], streamPtr[%p].",
866 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, qpn, wqeIndex, streamPtr);
867 4 : MACRO_THROW(RuntimeApiException, msg);
868 1 : }
869 0 : }
870 :
871 1 : void HrtRDMADBSend(uint32_t dbindex, uint64_t dbinfo, aclrtStream streamPtr)
872 : {
873 3 : HCCL_INFO("[HrtRDMADBSend] dbindex[%u], dbinfo[%llu], streamPtr[%p].", dbindex, dbinfo, streamPtr);
874 1 : rtError_t ret = rtRDMADBSend(dbindex, dbinfo, streamPtr);
875 1 : if (ret != RT_ERROR_NONE) {
876 : string msg = StringFormat("[rtRDMADBSend]errNo[0x%016llx] rt rdma send fail. "
877 : "return[%d]. para: dbindex[%u], dbinfo[%llu], streamPtr[%p].",
878 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, dbindex, dbinfo, streamPtr);
879 4 : MACRO_THROW(RuntimeApiException, msg);
880 1 : }
881 0 : }
882 :
883 41 : void HrtGetTaskIdAndStreamID(u32 &taskId, u32 &streamId)
884 : {
885 41 : rtError_t ret = rtGetTaskIdAndStreamID(&taskId, &streamId);
886 123 : HCCL_INFO("[HrtGetTaskIdAndStreamID] ret[%d], para: taskId[%u], streamId[%u].", ret, taskId, streamId);
887 41 : if (ret != RT_ERROR_NONE) {
888 : string msg = StringFormat("[Get][TaskIdAndStreamID]errNo[0x%016llx] "
889 : "rt get task ID and stream ID fail. return[%d], taskId[%u], streamId[%u].",
890 1 : HCCL_ERROR_CODE(HcclResult::HCCL_E_RUNTIME), ret, taskId, streamId);
891 4 : MACRO_THROW(RuntimeApiException, msg);
892 1 : }
893 40 : }
894 :
895 6 : void HrtUbDbSend(const HrtUbDbInfo &info, aclrtStream streamPtr)
896 : {
897 6 : THROW<NotSupportException>(StringFormat("Unsupported rtUbDbSend"));
898 : }
899 :
900 2 : void HrtUbDirectSend(const HrtUbWqeInfo &info, aclrtStream streamPtr)
901 : {
902 2 : THROW<NotSupportException>(StringFormat("Unsupported rtUbDirectSend"));
903 : }
904 :
905 64 : aclrtCntNotify HrtCntNotifyCreate(u32 deviceId)
906 : {
907 : aclrtCntNotify handle;
908 64 : aclError ret = aclrtCntNotifyCreate(&handle, RT_NOTIFY_FLAG_DEFAULT);
909 192 : HCCL_INFO("Call aclrtCntNotifyCreate, return value[%d] devId[%u].", ret, deviceId);
910 64 : if (ret != ACL_SUCCESS) {
911 0 : string msg = StringFormat("Call aclrtCntNotifyCreate failed");
912 0 : THROW<RuntimeApiException>(msg);
913 0 : }
914 64 : return handle;
915 : }
916 :
917 64 : u32 HrtGetCntNotifyId(const aclrtCntNotify inCntNotify)
918 : {
919 64 : u32 notifyId = 0; // 待接口rtGetCntNotifyId(inCntNotify, notifyId)上库，目前打桩;
920 64 : aclError ret = aclrtCntNotifyGetId(inCntNotify, ¬ifyId);
921 192 : HCCL_INFO("[HrtGetCntNotifyId] ret[%d], inCntNotify[%p], notifyId[%u]", ret, inCntNotify, notifyId);
922 64 : if (ret != ACL_SUCCESS) {
923 : string msg = StringFormat("Call rtGetCntNotifyId failed. return[%d], inCntNotify[%p], notifyId[%u].",
924 0 : ret, inCntNotify, notifyId);
925 0 : THROW<RuntimeApiException>(msg);
926 0 : }
927 64 : return notifyId;
928 : }
929 :
930 80 : void HrtCntNotifyDestroy(const aclrtCntNotify inCntNotify)
931 : {
932 80 : aclError ret = aclrtCntNotifyDestroy(inCntNotify);
933 240 : HCCL_INFO("[HrtCntNotifyDestroy] ret[%d], inCntNotify[%p].", ret, inCntNotify);
934 80 : if (ret != ACL_SUCCESS) {
935 0 : string msg = StringFormat("Call aclrtCntNotifyDestroy failed");
936 0 : THROW<RuntimeApiException>(msg);
937 0 : }
938 80 : }
939 :
940 : const std::map<HrtCntNotifyRecordMode, aclrtCntNotifyRecordMode> HRT_CNT_NOTIFY_RECORD_MODE_MAP
941 : = {{HrtCntNotifyRecordMode::WRITE_BIT, aclrtCntNotifyRecordMode::ACL_RT_CNT_NOTIFY_RECORD_BIT_OR_MODE},
942 : {HrtCntNotifyRecordMode::STORE, aclrtCntNotifyRecordMode::ACL_RT_CNT_NOTIFY_RECORD_SET_VALUE_MODE}};
943 19 : void HrtCntNotifyRecord(const aclrtCntNotify inCntNotify, const aclrtStream streamPtr, HrtCntNotifyRecordMode mode, u32 value)
944 : {
945 19 : aclrtCntNotifyRecordInfo recordInfo{};
946 19 : recordInfo.mode = HRT_CNT_NOTIFY_RECORD_MODE_MAP.at(mode);
947 19 : recordInfo.value = value;
948 19 : aclError ret = aclrtCntNotifyRecord(inCntNotify, streamPtr, &recordInfo);
949 57 : HCCL_INFO("[HrtCntNotifyRecord] inCntNotify[%p], streamPtr[%p], mode[%d], value[%u], ret[%d].",
950 : inCntNotify, streamPtr, mode, value, ret);
951 19 : if (ret != ACL_SUCCESS) {
952 0 : string msg = StringFormat("Call aclrtCntNotifyRecord failed");
953 0 : THROW<RuntimeApiException>(msg);
954 0 : }
955 19 : }
956 : // david接口 包间接口
957 : const std::map<HrtCntNotifyWaitMode, aclrtCntNotifyWaitMode> HRT_CNT_NOTIFY_WAIT_MODE_MAP
958 : = {{HrtCntNotifyWaitMode::EQUAL, aclrtCntNotifyWaitMode::ACL_RT_CNT_NOTIFY_WAIT_EQUAL_MODE},
959 : {HrtCntNotifyWaitMode::BITMAP, aclrtCntNotifyWaitMode::ACL_RT_CNT_NOTIFY_WAIT_EQUAL_WITH_BITMASK_MODE}};
960 19 : void HrtCntNotifyWaitWithTimeOut(const aclrtCntNotify inCntNotify, const aclrtStream streamPtr, HrtCntNotifyWaitMode
961 : mode, u32 value, u32 timeout, bool isClear)
962 : {
963 19 : aclrtCntNotifyWaitInfo waitInfo{};
964 19 : waitInfo.mode = HRT_CNT_NOTIFY_WAIT_MODE_MAP.at(mode);
965 19 : waitInfo.value = value;
966 19 : waitInfo.isClear = isClear;
967 19 : waitInfo.timeout = timeout;
968 19 : aclError ret = aclrtCntNotifyWaitWithTimeout(inCntNotify, streamPtr, &waitInfo);
969 57 : HCCL_INFO("[HrtCntNotifyWaitWithTimeOut] inCntNotify[%p], streamPtr[%p], mode[%d], "
970 : "value[%u], timeout[%u], isClear[%d], ret[%d].",
971 : inCntNotify, streamPtr, mode, value, timeout, isClear, ret);
972 19 : if (ret != ACL_SUCCESS) {
973 : string msg = StringFormat("Call rtCntNotifyWaitWithTimeout failed. return[%d], inCntNotify[%p], "
974 : "streamPtr[%p], mode[%d], value[%u], timeout[%u], isClear[%d].",
975 0 : ret, inCntNotify, streamPtr, mode, value, timeout, isClear);
976 0 : THROW<RuntimeApiException>(msg);
977 0 : }
978 19 : }
979 :
980 3 : aclrtNotify HrtNotifyCreateWithFlag(u32 devId, u32 flag)
981 : {
982 3 : aclrtNotify ptr = nullptr;
983 3 : aclError ret = aclrtCreateNotify(&ptr, flag);
984 9 : HCCL_INFO("Call HrtNotifyCreateWithFlag, return value[%d], flag[%u] devid[%u].", ret, flag, devId);
985 3 : if (ret != ACL_SUCCESS) {
986 : string msg = StringFormat("Call rtNotifyCreateWithFlag failed. return[%d], devId[%u], flag[%u].",
987 1 : ret, devId, flag);
988 1 : THROW<RuntimeApiException>(msg);
989 1 : }
990 2 : return ptr;
991 : }
992 :
993 2 : RtNotify_t HrtIpcOpenNotifyWithFlag(const char_t *name, uint32_t flags)
994 : {
995 6 : HCCL_INFO("[HrtIpcOpenNotifyWithFlag] name[%s], flags[%u].", name, flags);
996 2 : RtNotify_t ptr = nullptr;
997 2 : aclError ret = aclrtNotifyImportByKey(&ptr, name, static_cast<uint64_t>(flags));
998 2 : if (ret != ACL_SUCCESS) {
999 : string msg = StringFormat("Call rtIpcOpenNotifyWithFlag failed. return[%d], name[%p], flags[%u], ptr[%p].",
1000 1 : ret, name, flags, ptr);
1001 1 : THROW<RuntimeApiException>(msg);
1002 1 : }
1003 1 : return ptr;
1004 : }
1005 :
1006 : // 兜底extern形式
1007 8 : void HrtAicpuLaunchKernelWithHostArgs(aclrtFuncHandle funcHandle, uint32_t numBlocks, aclrtStream stream,
1008 : aclrtLaunchKernelCfg *cfg, void *hostArgs, size_t argsSize,
1009 : aclrtPlaceHolderInfo *placeHolderArray, size_t placeHolderNum)
1010 : {
1011 8 : rtError_t ret = aclrtLaunchKernelWithHostArgs(funcHandle, numBlocks, stream, cfg, hostArgs, argsSize,
1012 : placeHolderArray, placeHolderNum);
1013 8 : if (ret != RT_ERROR_NONE) {
1014 1 : THROW<RuntimeApiException>(StringFormat("Call aclrtLaunchKernelWithHostArgs failed, with ret[%d]", ret));
1015 : }
1016 7 : }
1017 :
1018 13 : void HrtRegTaskFailCallbackByModule(aclrtExceptionInfoCallback callback)
1019 : {
1020 39 : HCCL_INFO("[HrtRegTaskFailCallbackByModule] callback[%p].", callback);
1021 13 : aclError ret = aclrtSetExceptionInfoCallback(callback);
1022 13 : if (ret != ACL_SUCCESS) {
1023 : string msg = StringFormat("Call aclrtSetExceptionInfoCallback failed. return[%d], callback[%p].",
1024 0 : ret, callback);
1025 0 : THROW<RuntimeApiException>(msg);
1026 0 : }
1027 13 : }
1028 :
1029 6 : u32 HrtStreamGetSqId(const aclrtStream ptr)
1030 : {
1031 18 : HCCL_INFO("[HrtStreamGetSqId] ptr[%p].", ptr);
1032 : u32 sqId;
1033 6 : rtError_t ret = rtStreamGetSqid(ptr, &sqId);
1034 6 : if (ret != RT_ERROR_NONE) {
1035 1 : string msg = StringFormat("Call rtStreamGetSqid failed. return[%d], ptr[%p], sqId[%u].", ret, ptr, sqId);
1036 1 : THROW<RuntimeApiException>(msg);
1037 1 : }
1038 5 : return sqId;
1039 : }
1040 :
1041 11 : u32 HrtStreamGetCqId(const aclrtStream ptr)
1042 : {
1043 33 : HCCL_INFO("[HrtStreamGetCqId] ptr[%p].", ptr);
1044 : u32 cqId;
1045 : u32 logicCqId;
1046 11 : rtError_t ret = rtStreamGetCqid(ptr, &cqId, &logicCqId);
1047 11 : if (ret != RT_ERROR_NONE) {
1048 0 : THROW<RuntimeApiException>(StringFormat("Call rtStreamGetCqid failed, with ret[%d]", ret));
1049 : }
1050 11 : return logicCqId;
1051 : }
1052 :
1053 20 : void HrtCcuLaunch(rtCcuTaskInfo_t &taskInfo, aclrtStream const streamPtr)
1054 : {
1055 60 : HCCL_INFO("[HrtCcuLaunch] taskInfo[%p], streamPtr[%p].", &taskInfo, streamPtr);
1056 20 : auto ret = rtCCULaunch(&taskInfo, streamPtr);
1057 20 : if (ret != RT_ERROR_NONE) {
1058 2 : std::string msg;
1059 2 : if (ret == ACL_ERROR_RT_STREAM_TASK_FULL) {
1060 : // task 队列满
1061 2 : msg = StringFormat("[%s] rtCCULaunch failed because the task queue on the stream is full. "
1062 : "ret[%d], param: taskInfo[%p], streamPtr[%p]. "
1063 : "Possible causes: 1) too many tasks have been submitted to the stream; "
1064 : "2) the HCCL buffer is configured too small.",
1065 1 : __func__, ret, &taskInfo, streamPtr);
1066 : } else {
1067 2 : msg = StringFormat("Call rtCCULaunch failed. return[%d], taskInfo[%p], streamPtr[%p].",
1068 1 : ret, &taskInfo, streamPtr);
1069 : }
1070 2 : THROW<RuntimeApiException>(msg);
1071 2 : }
1072 18 : }
1073 :
1074 37 : void HrtUbDevQueryInfo(rtUbDevQueryCmd cmd, void *devInfo)
1075 : {
1076 111 : HCCL_INFO("[HrtUbDevQueryInfo] cmd[%d], devInfo[%p].", cmd, devInfo);
1077 37 : auto ret = rtUbDevQueryInfo(cmd, devInfo);
1078 37 : if (ret != RT_ERROR_NONE) {
1079 : string msg = StringFormat("Call rtUbDevQueryInfo failed. return[%d], cmd[%d], devInfo[%p].",
1080 1 : ret, cmd, devInfo);
1081 1 : THROW<RuntimeApiException>(msg);
1082 1 : }
1083 36 : if (cmd == QUERY_PROCESS_TOKEN) {
1084 36 : rtMemUbTokenInfo *info = static_cast<rtMemUbTokenInfo *>(devInfo);
1085 36 : info->tokenId = info->tokenId >> TOKEN_ID_RIGHT_SHIF;
1086 : }
1087 36 : }
1088 : // pair<tokendId, tokenValue>
1089 9 : std::pair<u32, u32> HrtUbDevQueryToken(u64 addr, u64 size)
1090 : {
1091 27 : HCCL_INFO("[HrtUbDevQueryToken] addr[%llu], size[%llu].", addr, size);
1092 : rtMemUbTokenInfo info;
1093 9 : info.va = addr;
1094 9 : info.size = size;
1095 9 : auto ret = rtUbDevQueryInfo(QUERY_PROCESS_TOKEN, &info);
1096 9 : if (ret != RT_ERROR_NONE) {
1097 3 : HCCL_WARNING("query(va=0x%llx, size=0x%llx) token failed, ret=%d", addr, size, ret);
1098 1 : return std::make_pair(0, 0);
1099 : }
1100 :
1101 8 : return {info.tokenId >> TOKEN_ID_RIGHT_SHIF, info.tokenValue};
1102 : }
1103 :
1104 : const std::map<HrtDevResProcType, rtDevResProcType_t> HRT_DEV_RES_PROC_TYPE_MAP
1105 : = {{HrtDevResProcType::PROCESS_CP1, RT_PROCESS_CP1}, {HrtDevResProcType::PROCESS_HCCP, RT_PROCESS_HCCP}};
1106 :
1107 : const std::map<HrtDevResType, rtDevResType_t> HRT_DEV_RES_TYPE_MAP
1108 : = {{HrtDevResType::RES_TYPE_STARS_NOTIFY_RECORD, RT_RES_TYPE_STARS_NOTIFY_RECORD},
1109 : {HrtDevResType::RES_TYPE_CCU_CKE, RT_RES_TYPE_CCU_CKE},
1110 : {HrtDevResType::RES_TYPE_CCU_XN, RT_RES_TYPE_CCU_XN},
1111 : {HrtDevResType::RES_TYPE_STARS_CNT_NOTIFY_BIT_WR, RT_RES_TYPE_STARS_CNT_NOTIFY_BIT_WR}};
1112 115 : HrtDevResAddrInfo HrtGetDevResAddress(const HrtDevResInfo &devResInfo)
1113 : {
1114 345 : HCCL_INFO("[HrtGetDevResAddress] devResInfo.dieId[%u], devResInfo.procType[%u], "
1115 : "devResInfo.resType[%u], devResInfo.flag[%u], devResInfo.resId[%u].",
1116 : devResInfo.dieId, devResInfo.procType, devResInfo.resType, devResInfo.flag, devResInfo.resId);
1117 : rtDevResInfo resInfo;
1118 115 : resInfo.dieId = devResInfo.dieId;
1119 115 : resInfo.procType = HRT_DEV_RES_PROC_TYPE_MAP.at(devResInfo.procType);
1120 115 : resInfo.resType = HRT_DEV_RES_TYPE_MAP.at(devResInfo.resType);
1121 115 : resInfo.flag = devResInfo.flag;
1122 115 : resInfo.resId = devResInfo.resId;
1123 :
1124 115 : uint64_t addr = 0;
1125 115 : u32 len = 0;
1126 : rtDevResAddrInfo addrInfo;
1127 115 : addrInfo.resAddress = &addr;
1128 115 : addrInfo.len = &len;
1129 115 : auto ret = rtGetDevResAddress(&resInfo, &addrInfo);
1130 115 : if (ret != RT_ERROR_NONE) {
1131 : string msg = StringFormat("Call rtGetDevResAddress failed. return[%d], devResInfo.dieId[%u], "
1132 : "devResInfo.procType[%u], devResInfo.resType[%u], devResInfo.flag[%u], "
1133 : "devResInfo.resId[%u].",
1134 1 : ret, devResInfo.dieId, devResInfo.procType, devResInfo.resType, devResInfo.flag,
1135 1 : devResInfo.resId);
1136 1 : THROW<RuntimeApiException>(msg);
1137 1 : }
1138 114 : HrtDevResAddrInfo devResAddrInfo;
1139 114 : devResAddrInfo.address = addr;
1140 114 : devResAddrInfo.len = len;
1141 342 : HCCL_INFO("devResAddrInfo.address[%llu], devResAddrInfo.len[%u].", devResAddrInfo.address, devResAddrInfo.len);
1142 114 : return devResAddrInfo;
1143 : }
1144 :
1145 115 : void HrtReleaseDevResAddress(const HrtDevResInfo &devResInfo)
1146 : {
1147 345 : HCCL_INFO("[HrtReleaseDevResAddress] devResInfo.dieId[%u], devResInfo.procType[%u], "
1148 : "devResInfo.resType[%u], devResInfo.flag[%u], devResInfo.resId[%u].",
1149 : devResInfo.dieId, devResInfo.procType, devResInfo.resType, devResInfo.flag, devResInfo.resId);
1150 : rtDevResInfo resInfo;
1151 115 : resInfo.dieId = devResInfo.dieId;
1152 115 : resInfo.procType = HRT_DEV_RES_PROC_TYPE_MAP.at(devResInfo.procType);
1153 115 : resInfo.resType = HRT_DEV_RES_TYPE_MAP.at(devResInfo.resType);
1154 115 : resInfo.flag = devResInfo.flag;
1155 115 : resInfo.resId = devResInfo.resId;
1156 :
1157 115 : rtError_t ret = rtReleaseDevResAddress(&resInfo);
1158 115 : if (ret != RT_ERROR_NONE) {
1159 : string msg = StringFormat("Call rtReleaseDevResAddress failed. return[%d], devResInfo.dieId[%u], "
1160 : "devResInfo.procType[%u],devResInfo.resType[%u], devResInfo.flag[%u], "
1161 : "devResInfo.resId[%u].",
1162 1 : ret, devResInfo.dieId, devResInfo.procType, devResInfo.resType,
1163 1 : devResInfo.flag, devResInfo.resId);
1164 1 : THROW<RuntimeApiException>(msg);
1165 1 : }
1166 114 : }
1167 :
1168 5 : aclrtEvent HrtEventCreateWithFlag(u32 flag)
1169 : {
1170 15 : HCCL_INFO("[HrtEventCreateWithFlag] flag[%u].", flag);
1171 5 : aclrtEvent ptr = nullptr;
1172 5 : aclError ret = aclrtCreateEventWithFlag(&ptr, flag);
1173 5 : if (ret != ACL_SUCCESS) {
1174 1 : string msg = StringFormat("Call rtEventCreateWithFlag failed. return[%d], flag[%u], ptr[%p].", ret, flag, ptr);
1175 1 : THROW<RuntimeApiException>(msg);
1176 1 : }
1177 4 : return ptr;
1178 : }
1179 :
1180 7 : void HrtEventDestroy(RtEvent_t eventPtr)
1181 : {
1182 21 : HCCL_INFO("[HrtEventDestroy] eventPtr[%p].", eventPtr);
1183 7 : aclError ret = aclrtDestroyEvent(eventPtr);
1184 7 : if (ret != ACL_SUCCESS) {
1185 1 : string msg = StringFormat("Call aclrtDestroyEvent failed. return[%d], eventPtr[%p].", ret, eventPtr);
1186 1 : THROW<RuntimeApiException>(msg);
1187 1 : }
1188 6 : }
1189 :
1190 4 : void HrtEventRecord(RtEvent_t eventPtr, aclrtStream streamPtr)
1191 : {
1192 12 : HCCL_INFO("[HrtEventRecord] eventPtr[%p], streamPtr[%p].", eventPtr, streamPtr);
1193 4 : aclError ret = aclrtRecordEvent(eventPtr, streamPtr);
1194 4 : if (ret != ACL_SUCCESS) {
1195 : string msg = StringFormat("Call aclrtRecordEvent failed. return[%d], eventPtr[%p], streamPtr[%p].",
1196 1 : ret, eventPtr, streamPtr);
1197 1 : THROW<RuntimeApiException>(msg);
1198 1 : }
1199 3 : }
1200 :
1201 : const std::map<aclrtEventWaitStatus, HrtEventStatus> HRT_EVENT_STATUS_MAP{
1202 : {ACL_EVENT_WAIT_STATUS_NOT_READY, HrtEventStatus::EVENT_INIT},
1203 : {ACL_EVENT_WAIT_STATUS_COMPLETE, HrtEventStatus::EVENT_RECORDED},
1204 : };
1205 :
1206 4 : HrtEventStatus HrtEventQueryStatus(RtEvent_t eventPtr)
1207 : {
1208 12 : HCCL_INFO("[HrtEventQueryStatus] eventPtr[%p].", eventPtr);
1209 4 : aclrtEventWaitStatus status = ACL_EVENT_WAIT_STATUS_NOT_READY;
1210 4 : aclError ret = aclrtQueryEventWaitStatus(eventPtr, &status);
1211 4 : if (ret != ACL_SUCCESS) {
1212 1 : string msg = StringFormat("Call aclrtQueryEventWaitStatus failed. return[%d], eventPtr[%p].", ret, eventPtr);
1213 1 : THROW<RuntimeApiException>(msg);
1214 1 : }
1215 3 : if (HRT_EVENT_STATUS_MAP.find(status) == HRT_EVENT_STATUS_MAP.end()) {
1216 0 : THROW<InvalidParamsException>(
1217 0 : StringFormat("event status[%u] not in HRT_EVENT_STATUS_MAP.", static_cast<u32>(status)));
1218 : }
1219 6 : return HRT_EVENT_STATUS_MAP.at(status);
1220 : }
1221 :
1222 6 : void HrtWriteValue(u64 addr, u32 piVal, const aclrtStream streamPtr)
1223 : {
1224 6 : THROW<NotSupportException>(StringFormat("Unsupported rtWriteValue"));
1225 : }
1226 :
1227 2 : void HrtDeviceAbortRegCallBack(aclrtDeviceTaskAbortCallback callback, void *args, const std::string& name)
1228 : {
1229 2 : aclError ret = aclrtSetDeviceTaskAbortCallback(name.c_str(), callback, args);
1230 2 : if (ret != ACL_SUCCESS) {
1231 0 : string msg = StringFormat("call rtSetTaskAbortCallBack failed. ret=[%d].", ret);
1232 0 : THROW<RuntimeApiException>(msg);
1233 0 : }
1234 2 : }
1235 :
1236 4372 : HcclResult HrtThreadExchangeCaptureMode(aclmdlRICaptureMode *mode)
1237 : {
1238 13116 : HCCL_INFO("[HrtThreadExchangeCaptureMode] mode[%p].", mode);
1239 4372 : aclError ret = aclmdlRICaptureThreadExchangeMode(mode);
1240 4372 : if (ret == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
1241 0 : HCCL_WARNING("[HrtThreadExchangeCaptureMode] rtThreadExchangeCaptureMode not support!, ret=%d, mode=%p.",
1242 : ret, mode);
1243 0 : return HCCL_E_NOT_SUPPORT;
1244 : } else {
1245 4372 : CHK_PRT_RET(ret != ACL_SUCCESS, HCCL_ERROR("[HrtThreadExchangeCaptureMode]rtThreadExchangeCaptureMode "
1246 : "failed mode:%d, return value[%d].", *mode, ret), HCCL_E_RUNTIME);
1247 : }
1248 4372 : return HCCL_SUCCESS;
1249 : }
1250 :
1251 0 : HcclResult HrtMemPrefetchToDevice(void *devPtr, uint64_t len)
1252 : {
1253 0 : CHK_PRT_RET(aclrtMemP2PMap == nullptr, HCCL_ERROR("aclrtMemP2PMap is nullptr, "
1254 : "Does not support this interface."), HCCL_E_RUNTIME);
1255 0 : aclError ret = aclrtMemP2PMap(devPtr, static_cast<size_t>(len), HrtGetDevice(), 0);
1256 0 : HCCL_INFO("[HrtMemPrefetchToDevice] devPtr[%p], len[%llu], ret[%d].", devPtr, len, ret);
1257 0 : if (ret != ACL_SUCCESS) {
1258 0 : HCCL_ERROR("aclrtMemP2PMap fail ret = %d", ret);
1259 0 : return HCCL_E_RUNTIME;
1260 : }
1261 0 : return HCCL_SUCCESS;
1262 : }
1263 :
1264 1 : HcclResult HrtEnableP2P(u32 deviceLogicId, u32 devicePhyId)
1265 : {
1266 1 : rtError_t ret = rtEnableP2P(deviceLogicId, devicePhyId, 0);
1267 :
1268 3 : HCCL_INFO("rt enableP2P deviceLogicId[%u] and devicePhyId[%u] ret[%d]", deviceLogicId, devicePhyId, ret);
1269 :
1270 1 : CHK_PRT_RET(ret != RT_ERROR_NONE, HCCL_ERROR("[Enable][P2P]errNo[0x%016llx] rt enableP2P deviceLogicId[%u] and "\
1271 : "devicePhyId[%u] fail[%d]", HCCL_ERROR_CODE(HCCL_E_RUNTIME), deviceLogicId, devicePhyId, ret), HCCL_E_RUNTIME);
1272 :
1273 1 : return HCCL_SUCCESS;
1274 : }
1275 :
1276 1 : HcclResult HrtDisableP2P(u32 deviceLogicId, u32 devicePhyId)
1277 : {
1278 1 : rtError_t ret = rtDisableP2P(deviceLogicId, devicePhyId);
1279 :
1280 3 : HCCL_INFO("rt disableP2P deviceLogicId[%u] and devicePhyId[%u] ret[%d]", deviceLogicId, devicePhyId, ret);
1281 :
1282 1 : CHK_PRT_RET(ret != RT_ERROR_NONE, HCCL_ERROR("[Disable][P2P]errNo[0x%016llx] rt disableP2P deviceLogicId[%u] and "\
1283 : "devicePhyId[%u] fail[%d]", HCCL_ERROR_CODE(HCCL_E_RUNTIME), deviceLogicId, devicePhyId, ret), HCCL_E_RUNTIME);
1284 1 : return HCCL_SUCCESS;
1285 : }
1286 :
1287 0 : HcclResult HrtGetP2PStatus(u32 deviceLogicId, u32 devicePhyId, uint32_t *status)
1288 : {
1289 0 : rtError_t ret = rtGetP2PStatus(deviceLogicId, devicePhyId, status);
1290 :
1291 0 : HCCL_DEBUG("rt getp2pstatus deviceLogicId[%u] and devicePhyId[%u] ret[%d], status[%u]",
1292 : deviceLogicId, devicePhyId, ret, *status);
1293 0 : CHK_PRT_RET(ret != RT_ERROR_NONE, HCCL_ERROR("[Get][P2PStatus]errNo[0x%016llx]Call rtGetP2PStatus failed, "
1294 : "ret[%d], deviceLogicId[%u], devicePhyId[%u]",
1295 : HCCL_ERROR_CODE(HCCL_E_RUNTIME), ret, deviceLogicId, devicePhyId), HCCL_E_RUNTIME);
1296 0 : return HCCL_SUCCESS;
1297 : }
1298 : } // namespace Hccl
|
