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