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 <thread>
12 : #include <adapter_hal.h>
13 : #include "dlhal_function.h"
14 : #include "log.h"
15 : #include "sal_pub.h"
16 : #include "aicpu_schedule/aicpu_mc2_maintenance_thread.h"
17 :
18 : using namespace hccl;
19 :
20 : int (*g_grpIdCallback)(int tag, int* grpId, int* devId) = nullptr;
21 : #ifdef __cplusplus
22 : extern "C" {
23 : #endif
24 :
25 : constexpr u32 MEMORY_PAGE_SIZE = 4096;
26 : constexpr u32 PRE_FETCH_THREADS_NUM = 24;
27 : constexpr u32 PRE_FETCH_MEMORY_THRESHOLD = 268435456; // 考虑到多线程预访问也有开销，只有在内存大于256MB时才启动预访问
28 :
29 : drvError_t __attribute__((weak))
30 : halResourceIdRestore(struct drvResIdKey* info); // custom进程notify资源同步，在调用halResourceIdCheck前调用
31 :
32 0 : HcclResult HcclSetGrpIdCallback(int (*grpIdCallback)(int tag, int* grpId, int* devId))
33 : {
34 0 : if (grpIdCallback == nullptr) {
35 0 : HCCL_ERROR("para grpIdCallback is nullptr");
36 0 : return HCCL_E_PARA;
37 : }
38 :
39 0 : g_grpIdCallback = grpIdCallback;
40 0 : HCCL_DEBUG("New grpIdCallback was set, grpIdCallback[%p]", grpIdCallback);
41 0 : return HCCL_SUCCESS;
42 : }
43 :
44 : #ifdef __cplusplus
45 : }
46 : #endif
47 :
48 0 : s32 hrtGetgrpId(int& groupId, int& devId)
49 : {
50 0 : if (g_grpIdCallback == nullptr) {
51 0 : groupId = HCCL_ESCHED_GROUP_ID;
52 0 : devId = HCCL_RESERVED_DEV_ID;
53 :
54 0 : HCCL_DEBUG("g_grpIdCallback is nullptr, event.grp_id[%d] = HCCL_ESCHED_GROUP_ID", groupId);
55 : } else {
56 0 : HCCL_DEBUG("g_grpIdCallback is not nullptr");
57 0 : s32 ret = g_grpIdCallback(0, &groupId, &devId);
58 0 : if (ret != 0) {
59 0 : HCCL_ERROR("g_grpIdCallback failed, ret[%d]", ret);
60 0 : return ret;
61 : }
62 :
63 0 : HCCL_DEBUG("g_grpIdCallback is not nullptr, g_grpIdCallback(0) event.grp_id[%d], devId[%d]", groupId, devId);
64 : }
65 :
66 0 : return 0;
67 : }
68 :
69 0 : HcclResult hrtHalSubmitEvent(u32 devId, u32 eventId, u32 groupId)
70 : {
71 0 : struct event_summary event = {};
72 0 : event.pid = SalGetPid();
73 0 : event.grp_id = groupId;
74 0 : event.event_id = static_cast<EVENT_ID>(eventId);
75 0 : event.subevent_id = 0;
76 0 : event.msg_len = 0;
77 0 : event.msg = nullptr;
78 0 : event.dst_engine = ACPU_DEVICE;
79 0 : event.policy = ONLY;
80 0 : for (u32 i = 0; i < EVENT_SUMMARY_RSV; i++) {
81 0 : event.rsv[i] = 0;
82 : }
83 :
84 0 : HCCL_DEBUG("SubmitEvent: event id:%u, pid:%d, grp id:%u, dev id:%u", eventId, event.pid, event.grp_id, devId);
85 :
86 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalEschedSubmitEvent(devId, &event);
87 0 : CHK_PRT_RET(
88 : ret != DRV_ERROR_NONE,
89 : HCCL_ERROR(
90 : "[Submit][Event]errNo[0x%016llx] halEschedSubmitEvent fail,"
91 : "return[%d], para: deviceLogicId[%u] group[%u] eventId[%u].",
92 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devId, event.grp_id, eventId),
93 : HCCL_E_DRV);
94 0 : return HCCL_SUCCESS;
95 : }
96 :
97 0 : HcclResult hrtHalEschedAttachDevice(unsigned int devId)
98 : {
99 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalEschedAttachDevice(devId);
100 0 : CHK_PRT_RET(
101 : ret != DRV_ERROR_NONE,
102 : HCCL_ERROR(
103 : "[Attach][Device]errNo[0x%016llx] hrtHalEschedAttachDevice fail,"
104 : "return[%d], para: deviceLogicId[%u].",
105 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devId),
106 : HCCL_E_DRV);
107 0 : return HCCL_SUCCESS;
108 : }
109 :
110 0 : HcclResult hrtHalEschedDettachDevice(unsigned int devId)
111 : {
112 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalEschedDettachDevice(devId);
113 0 : CHK_PRT_RET(
114 : ret != DRV_ERROR_NONE,
115 : HCCL_ERROR(
116 : "[Detach][Device]errNo[0x%016llx] hrtHalEschedDettachDevice fail,"
117 : "return[%d], para: deviceLogicId[%u].",
118 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devId),
119 : HCCL_E_DRV);
120 0 : return HCCL_SUCCESS;
121 : }
122 :
123 0 : HcclResult hrtHalGetAPIVersion(int& apiVersion)
124 : {
125 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalGetAPIVersion(&apiVersion);
126 0 : CHK_PRT_RET(
127 : ret != DRV_ERROR_NONE,
128 : HCCL_ERROR(
129 : "[Get][APIVersion]errNo[0x%016llx] dlHalGetAPIVersion fail,"
130 : "return[%d], para: apiVersion[%d].",
131 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, apiVersion),
132 : HCCL_E_DRV);
133 0 : return HCCL_SUCCESS;
134 : }
135 :
136 0 : HcclResult hrtHalEschedCreateGrp(unsigned int devId, unsigned int grpId, GROUP_TYPE type)
137 : {
138 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalEschedCreateGrp(devId, grpId, type);
139 0 : CHK_PRT_RET(
140 : ret == DRV_ERROR_GROUP_EXIST,
141 : HCCL_INFO("hal event group is exist, devId[%u] grpId[%u] group type[%u]", devId, grpId, type), HCCL_SUCCESS);
142 0 : CHK_PRT_RET(
143 : ret != DRV_ERROR_NONE,
144 : HCCL_ERROR(
145 : "[hrtHalEschedCreateGrp]errNo[0x%016llx] hrtHalEschedCreateGrp fail,"
146 : "return[%d], para: devId[%u].",
147 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devId),
148 : HCCL_E_DRV);
149 0 : return HCCL_SUCCESS;
150 : }
151 :
152 0 : HcclResult hrtHalEschedCreateGrpEx(
153 : [[maybe_unused]] unsigned int devId, [[maybe_unused]] unsigned int* grpId, [[maybe_unused]] unsigned int threadNum,
154 : [[maybe_unused]] GROUP_TYPE type)
155 : {
156 0 : return HCCL_SUCCESS;
157 : }
158 :
159 0 : HcclResult hrtHalEschedSubscribeEvent(
160 : [[maybe_unused]] unsigned int devId, [[maybe_unused]] unsigned int grpId, [[maybe_unused]] unsigned int threadId,
161 : [[maybe_unused]] unsigned long long eventBitmap)
162 : {
163 0 : return HCCL_SUCCESS;
164 : }
165 :
166 0 : HcclResult hrtHalEschedWaitEvent(
167 : [[maybe_unused]] unsigned int devId, [[maybe_unused]] unsigned int grpId, [[maybe_unused]] unsigned int threadId,
168 : [[maybe_unused]] int timeout, [[maybe_unused]] struct event_info* event)
169 : {
170 0 : return HCCL_SUCCESS;
171 : }
172 :
173 0 : HcclResult hrtHalEschedRegisterAckFunc(
174 : unsigned int eventId, void (*ackFunc)(unsigned int devId, unsigned int subeventId, u8* msg, unsigned int msgLen))
175 : {
176 0 : CHK_PTR_NULL(ackFunc);
177 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalEschedRegisterAckFunc(HCCL_ESCHED_GROUP_ID, eventId, ackFunc);
178 0 : CHK_PRT_RET(
179 : ret != DRV_ERROR_NONE,
180 : HCCL_ERROR(
181 : "errNo[0x%016llx] hrtHalEschedRegisterAckFunc fail,"
182 : "return[%d], para: eventId[%u].",
183 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, eventId),
184 : HCCL_E_DRV);
185 0 : return HCCL_SUCCESS;
186 : }
187 :
188 0 : HcclResult hrtHalEschedRegisterAckFuncWithGrpid(
189 : unsigned int grpid, unsigned int eventId,
190 : void (*ackFunc)(unsigned int devId, unsigned int subeventId, u8* msg, unsigned int msgLen))
191 : {
192 0 : CHK_PTR_NULL(ackFunc);
193 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalEschedRegisterAckFunc(grpid, eventId, ackFunc);
194 0 : CHK_PRT_RET(
195 : ret != DRV_ERROR_NONE,
196 : HCCL_ERROR(
197 : "errNo[0x%016llx] hrtHalEschedRegisterAckFunc fail,"
198 : "return[%d], para: eventId[%u].",
199 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, eventId),
200 : HCCL_E_DRV);
201 0 : return HCCL_SUCCESS;
202 : }
203 :
204 0 : HcclResult hrtHalDrvOpenIpcNotify([[maybe_unused]] const char* name, [[maybe_unused]] struct drvIpcNotifyInfo* notify)
205 : {
206 0 : return HCCL_SUCCESS;
207 : }
208 :
209 0 : HcclResult hrtHalDrvCloseIpcNotify([[maybe_unused]] const char* name, [[maybe_unused]] struct drvIpcNotifyInfo* notify)
210 : {
211 0 : return HCCL_SUCCESS;
212 : }
213 :
214 0 : HcclResult hrtHalDrvIpcNotifyRecord([[maybe_unused]] const char* name) { return HCCL_SUCCESS; }
215 :
216 3243 : HcclResult HrtHalDrvQueryProcessHostPid(
217 : int pid, unsigned int* chipId, unsigned int* vfid, unsigned int* hostPid, unsigned int* cpType)
218 : {
219 3243 : if (UNLIKELY(!hccl::DlHalFunction::GetInstance().DlHalFunctionIsInit())) {
220 2 : CHK_RET(DlHalFunction::GetInstance().DlHalFunctionInit());
221 : }
222 :
223 3243 : CHK_PTR_NULL(hostPid);
224 : // 和底软确认，chipId、vfid、hostPid、cpType不需要校验空指针，如果传入空指针表示当前不获取该值
225 3243 : drvError_t ret = DlHalFunction::GetInstance().dlHalDrvQueryProcessHostPid(pid, chipId, vfid, hostPid, cpType);
226 3243 : CHK_PRT_RET(
227 : ret != DRV_ERROR_NONE,
228 : HCCL_ERROR(
229 : "errNo[0x%016llx] HrtHalDrvQueryProcessHostPid fail,"
230 : "return[%d], para: pid[%d].",
231 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, pid),
232 : HCCL_E_DRV);
233 3243 : HCCL_INFO("HrtHalDrvQueryProcessHostPid pid[%d] hostPid[%u]", pid, *hostPid);
234 3243 : return HCCL_SUCCESS;
235 : }
236 :
237 0 : HcclResult HrtHalDrvGetDevIDByLocalDevID(uint32_t localDevId, uint32_t* devId)
238 : {
239 0 : if (UNLIKELY(!hccl::DlHalFunction::GetInstance().DlHalFunctionIsInit())) {
240 0 : CHK_RET(DlHalFunction::GetInstance().DlHalFunctionInit());
241 : }
242 :
243 0 : CHK_PTR_NULL(devId);
244 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalDrvGetDevIDByLocalDevID(localDevId, devId);
245 0 : CHK_PRT_RET(
246 : ret != DRV_ERROR_NONE,
247 : HCCL_ERROR(
248 : "errNo[0x%016llx] HrtHalDrvGetDevIDByLocalDevID fail,"
249 : "return[%d], para: localDevId[%d].",
250 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, localDevId),
251 : HCCL_E_DRV);
252 0 : HCCL_INFO("HrtHalDrvGetDevIDByLocalDevID localDevId[%d] devId[%u]", localDevId, *devId);
253 0 : return HCCL_SUCCESS;
254 : }
255 :
256 0 : HcclResult hrtDrvMemCpy(void* dst, uint64_t destMax, const void* src, uint64_t count)
257 : {
258 : // 参数有效性检查
259 0 : CHK_PTR_NULL(dst);
260 0 : CHK_PTR_NULL(src);
261 :
262 0 : uint64_t dstAddr = reinterpret_cast<uintptr_t>(dst);
263 0 : uint64_t srcAddr = reinterpret_cast<uintptr_t>(const_cast<void*>(src));
264 0 : drvError_t ret = DlHalFunction::GetInstance().dlDrvMemCpy(dstAddr, destMax, srcAddr, count);
265 0 : CHK_PRT_RET(
266 : ret != DRV_ERROR_NONE,
267 : HCCL_ERROR(
268 : "errNo[0x%016llx] hrtDrvMemCpy fail,"
269 : "return[%d].",
270 : HCCL_ERROR_CODE(HCCL_E_DRV), ret),
271 : HCCL_E_DRV);
272 0 : return HCCL_SUCCESS;
273 : }
274 :
275 1807 : HcclResult hrtDrvGetDevNum(uint32_t* num_dev)
276 : {
277 : // 参数有效性检查
278 1807 : CHK_PTR_NULL(num_dev);
279 1807 : drvError_t ret = DlHalFunction::GetInstance().dlHalDrvGetDevNum(num_dev);
280 1807 : if (ret == DRV_ERROR_NOT_SUPPORT) {
281 : // 通用服务器不支持该接口，默认num_dev为0，返回成功
282 0 : *num_dev = 0;
283 0 : return HCCL_SUCCESS;
284 : }
285 1807 : CHK_PRT_RET(
286 : ret != DRV_ERROR_NONE,
287 : HCCL_ERROR(
288 : "errNo[0x%016llx] hrtDrvGetDevNum fail,"
289 : "return[%d].",
290 : HCCL_ERROR_CODE(HCCL_E_DRV), ret),
291 : HCCL_E_DRV);
292 1807 : return HCCL_SUCCESS;
293 : }
294 :
295 530 : HcclResult hrtHalGetDeviceInfo(uint32_t devId, int32_t moduleType, int32_t infoType, int64_t* value)
296 : {
297 : // 参数有效性检查
298 530 : CHK_PTR_NULL(value);
299 530 : if (UNLIKELY(!hccl::DlHalFunction::GetInstance().DlHalFunctionIsInit())) {
300 0 : CHK_RET(DlHalFunction::GetInstance().DlHalFunctionInit());
301 : }
302 530 : HCCL_INFO("Entry-hrtHalGetDeviceInfo");
303 530 : drvError_t ret = DlHalFunction::GetInstance().dlHalGetDeviceInfo(devId, moduleType, infoType, value);
304 529 : CHK_PRT_RET(
305 : ret == DRV_ERROR_NOT_SUPPORT,
306 : HCCL_WARNING(
307 : "hrtHalGetDeviceInfo not support, "
308 : "return[%d].",
309 : HCCL_ERROR_CODE(DRV_ERROR_NOT_SUPPORT), ret),
310 : HCCL_E_NOT_SUPPORT);
311 529 : CHK_PRT_RET(
312 : ret != DRV_ERROR_NONE,
313 : HCCL_ERROR(
314 : "errNo[0x%016llx] hrtHalGetDeviceInfo fail,"
315 : "return[%d].",
316 : HCCL_ERROR_CODE(HCCL_E_DRV), ret),
317 : HCCL_E_DRV);
318 529 : return HCCL_SUCCESS;
319 : }
320 :
321 0 : void hrtDrvDeviceGetBareTgid(s32& pid)
322 : {
323 0 : pid = DlHalFunction::GetInstance().dlDrvDeviceGetBareTgid();
324 :
325 0 : return;
326 : }
327 :
328 0 : HcclResult hrtHalGrpQuery(GroupQueryCmdType cmd, void* inBuff, unsigned int inLen, void* outBuff, unsigned int* outLen)
329 : {
330 0 : CHK_PTR_NULL(inBuff);
331 0 : CHK_PTR_NULL(outBuff);
332 0 : CHK_PTR_NULL(outLen);
333 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalGrpQuery(cmd, inBuff, inLen, outBuff, outLen);
334 0 : CHK_PRT_RET(ret == DRV_ERROR_NOT_SUPPORT, HCCL_WARNING("dlHalGrpQuery is not support."), HCCL_SUCCESS);
335 0 : CHK_PRT_RET(
336 : ret != DRV_ERROR_NONE,
337 : HCCL_ERROR(
338 : "errNo[0x%016llx] hrtHalGrpQuery fail,"
339 : "return[%d], para: cmd[%d].",
340 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, cmd),
341 : HCCL_E_DRV);
342 0 : return HCCL_SUCCESS;
343 : }
344 :
345 0 : HcclResult hrtEschedQueryInfo(
346 : [[maybe_unused]] unsigned int devId, [[maybe_unused]] ESCHED_QUERY_TYPE type,
347 : [[maybe_unused]] struct esched_input_info* inPut, [[maybe_unused]] struct esched_output_info* outPut)
348 : {
349 0 : return HCCL_SUCCESS;
350 : }
351 :
352 827 : HcclResult hrtDrvGetPlatformInfo(uint32_t* info)
353 : {
354 : // 参数有效性检查
355 827 : CHK_PTR_NULL(info);
356 827 : CHK_SMART_PTR_NULL(DlHalFunction::GetInstance().dlHalDrvGetPlatformInfo);
357 827 : HCCL_INFO("Entry-hrtDrvGetPlatformInfo");
358 827 : drvError_t ret = DlHalFunction::GetInstance().dlHalDrvGetPlatformInfo(info);
359 827 : CHK_PRT_RET(
360 : ret != DRV_ERROR_NONE,
361 : HCCL_ERROR(
362 : "errNo[0x%016llx] hrtDrvGetPlatformInfo fail,"
363 : "return[%d].",
364 : HCCL_ERROR_CODE(HCCL_E_DRV), ret),
365 : HCCL_E_DRV);
366 827 : return HCCL_SUCCESS;
367 : }
368 :
369 531 : HcclResult hrtHalGetChipInfo(uint32_t devId, std::string& chipName)
370 : {
371 : // 参数有效性检查
372 531 : CHK_SMART_PTR_NULL(DlHalFunction::GetInstance().dlHalGetChipInfo);
373 531 : halChipInfo chipInfo = {};
374 531 : drvError_t ret = DlHalFunction::GetInstance().dlHalGetChipInfo(devId, &chipInfo);
375 531 : CHK_PRT_RET(
376 : ret != DRV_ERROR_NONE,
377 : HCCL_ERROR(
378 : "errNo[0x%016llx] hrtHalGetChipInfo fail,"
379 : "return[%d].",
380 : HCCL_ERROR_CODE(HCCL_E_DRV), ret),
381 : HCCL_E_DRV);
382 : chipName
383 1593 : = std::string(reinterpret_cast<char*>(chipInfo.type)) + std::string(reinterpret_cast<char*>(chipInfo.name));
384 531 : HCCL_INFO("hrtHalGetChipInfo succ chipName[%s]", chipName.c_str());
385 531 : return HCCL_SUCCESS;
386 : }
387 :
388 0 : HcclResult hrtHalBindCgroup(BIND_CGROUP_TYPE bindType)
389 : {
390 0 : if (DlHalFunction::GetInstance().dlHalBindCgroup == nullptr) {
391 0 : HCCL_ERROR("dlHalBindCgroup is nullptr, can not use dlHalBindCgroup");
392 0 : return HCCL_E_DRV;
393 : }
394 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalBindCgroup(bindType);
395 0 : CHK_PRT_RET(
396 : ret != DRV_ERROR_NONE,
397 : HCCL_ERROR(
398 : "errNo[0x%016llx] hrtHalBindCgroup fail,"
399 : "return[%d].",
400 : HCCL_ERROR_CODE(HCCL_E_DRV), ret),
401 : HCCL_E_DRV);
402 0 : return HCCL_SUCCESS;
403 : }
404 :
405 0 : HcclResult hrtDrvDeviceGetPhyIdByIndex([[maybe_unused]] u32 deviceLogicId, [[maybe_unused]] u32& devicePhyId)
406 : {
407 0 : return HCCL_SUCCESS;
408 : }
409 :
410 0 : void MemoryPreFetchImpl(u64 start, u64 end, u32 pageSize)
411 : {
412 : // 多线程并发对待映射的内存进行逐页表的预访问
413 0 : volatile uint64_t* ptr = nullptr;
414 0 : for (u64 i = start; i < end; i += pageSize) {
415 0 : ptr = reinterpret_cast<volatile uint64_t*>(i);
416 0 : *ptr;
417 : }
418 0 : }
419 :
420 0 : HcclResult MemoryPreFetch(u64 size, void* hostPtr)
421 : {
422 0 : if (size >= PRE_FETCH_MEMORY_THRESHOLD) {
423 0 : std::vector<std::unique_ptr<std::thread>> threads(PRE_FETCH_THREADS_NUM);
424 0 : u64 chunkSize = size / PRE_FETCH_THREADS_NUM;
425 0 : u64 hostPtrUpperLimit = size + reinterpret_cast<uintptr_t>(hostPtr);
426 0 : for (unsigned int i = 0; i < PRE_FETCH_THREADS_NUM; ++i) {
427 0 : u64 start = i * chunkSize + reinterpret_cast<uintptr_t>(hostPtr);
428 0 : u64 end = (start + chunkSize < hostPtrUpperLimit) ? start + chunkSize : hostPtrUpperLimit;
429 0 : threads[i].reset(new (std::nothrow) std::thread(&MemoryPreFetchImpl, start, end, MEMORY_PAGE_SIZE));
430 0 : CHK_PRT_RET(
431 : !threads[i], HCCL_ERROR("[MemoryPreFetch]threads[%d] threads reset failed.", i), HCCL_E_INTERNAL);
432 : }
433 :
434 0 : for (auto& thread : threads) {
435 0 : thread->join();
436 : }
437 0 : }
438 0 : return HCCL_SUCCESS;
439 : }
440 :
441 990 : HcclResult hrtHalHostRegister(void* hostPtr, u64 size, u32 flag, u32 devid, void*& devPtr)
442 : {
443 990 : CHK_PTR_NULL(hostPtr);
444 990 : if (flag == HOST_MEM_MAP_DEV_PCIE_TH || flag == HOST_MEM_MAP_DEV) {
445 0 : CHK_RET(MemoryPreFetch(size, hostPtr));
446 : }
447 :
448 990 : if (DlHalFunction::GetInstance().dlHalHostRegister == nullptr) {
449 0 : HCCL_ERROR("dlHalHostRegister is nullptr, can not use dlHalHostRegister");
450 0 : return HCCL_E_DRV;
451 : }
452 :
453 990 : drvError_t ret = DlHalFunction::GetInstance().dlHalHostRegister(hostPtr, size, flag, devid, &devPtr);
454 990 : CHK_PRT_RET(
455 : ret != DRV_ERROR_NONE,
456 : HCCL_ERROR(
457 : "[hrtHalHostRegister]errNo[0x%016llx]"
458 : "hrtHalHostRegister fail, return[%d], para: size[%llu] flag[%u] devid[%u].",
459 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, size, flag, devid),
460 : HCCL_E_DRV);
461 990 : return HCCL_SUCCESS;
462 : }
463 :
464 1000 : HcclResult hrtHalHostUnregister(void* hostPtr, u32 devid)
465 : {
466 1000 : CHK_PTR_NULL(hostPtr);
467 1000 : if (DlHalFunction::GetInstance().dlHalHostUnregister == nullptr) {
468 0 : HCCL_ERROR("dlHalHostUnregister is nullptr, can not use dlHalHostUnregister");
469 0 : return HCCL_E_DRV;
470 : }
471 :
472 1002 : drvError_t ret = DlHalFunction::GetInstance().dlHalHostUnregister(hostPtr, devid);
473 1002 : CHK_PRT_RET(
474 : ret != DRV_ERROR_NONE,
475 : HCCL_ERROR(
476 : "[hrtHalHostUnregister]errNo[0x%016llx]"
477 : "hrtHalHostUnregister fail, return[%d], para: devid[%u].",
478 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devid),
479 : HCCL_E_DRV);
480 :
481 1002 : return HCCL_SUCCESS;
482 : }
483 :
484 0 : HcclResult hrtHalHostUnregisterEx(void* hostPtr, u32 devid, u32 flag)
485 : {
486 0 : CHK_PTR_NULL(hostPtr);
487 0 : if (DlHalFunction::GetInstance().dlHalHostUnregisterEx == nullptr) {
488 0 : HCCL_ERROR("dlHalHostUnregisterEx is nullptr, can not use dlHalHostUnregisterEx");
489 0 : return HCCL_E_DRV;
490 : }
491 :
492 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalHostUnregisterEx(hostPtr, devid, flag);
493 0 : CHK_PRT_RET(
494 : ret != DRV_ERROR_NONE,
495 : HCCL_ERROR(
496 : "[hrtHalHostUnregisterEx]errNo[0x%016llx]"
497 : "hrtHalHostUnregisterEx fail, return[%d], para: devid[%u].",
498 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devid),
499 : HCCL_E_DRV);
500 :
501 0 : return HCCL_SUCCESS;
502 : }
503 :
504 1156 : HcclResult hrtHalMemCtl(int type, void* input, size_t inputSize, void* output, size_t* outputSize)
505 : {
506 1156 : CHK_PTR_NULL(input);
507 1156 : CHK_PTR_NULL(output);
508 1156 : CHK_PTR_NULL(outputSize);
509 1156 : if (DlHalFunction::GetInstance().dlHalMemCtl == nullptr) {
510 0 : HCCL_ERROR("dlHalMemCtl is nullptr, can not use dlHalMemCtl");
511 0 : return HCCL_E_DRV;
512 : }
513 :
514 1156 : drvError_t ret = DlHalFunction::GetInstance().dlHalMemCtl(type, input, inputSize, output, outputSize);
515 1156 : CHK_PRT_RET(
516 : ret != DRV_ERROR_NONE,
517 : HCCL_ERROR(
518 : "[dlHalMemCtl]errNo[0x%016llx]"
519 : "dlHalMemCtl fail, return[%d], para: type[%u].",
520 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, type),
521 : HCCL_E_DRV);
522 :
523 1156 : return HCCL_SUCCESS;
524 : }
525 :
526 0 : HcclResult hrtHalSensorNodeRegister([[maybe_unused]] uint32_t devId, [[maybe_unused]] uint64_t* handle)
527 : {
528 : #ifdef CCL_KERNEL
529 0 : CHK_PTR_NULL(handle);
530 0 : if (UNLIKELY(!hccl::DlHalFunction::GetInstance().DlHalFunctionIsInit())) {
531 0 : CHK_RET(DlHalFunction::GetInstance().DlHalFunctionInit());
532 : }
533 0 : if (DlHalFunction::GetInstance().dlHalSensorNodeRegister == nullptr) {
534 0 : HCCL_ERROR("dlHalSensorNodeRegister is nullptr, can not use dlHalSensorNodeRegister");
535 0 : return HCCL_E_DRV;
536 : }
537 :
538 0 : constexpr uint32_t HCCL_ASSERT_EVENT_MASK = 0xE00; // 当前仅使能 bit 9-B
539 0 : constexpr uint32_t HCCL_DEASSERT_EVENT_MASK = 0x0; // 0x09/0x0A/0x0B 使能为通知事件
540 : // 构造 Sensor Node 注册参数
541 0 : halSensorNodeCfg cfg = {};
542 0 : cfg.NodeType = HAL_DMS_DEV_TYPE_HCCP;
543 0 : cfg.SensorType = SAFTY_STATE_SENSOR_TYTPE;
544 0 : cfg.AssertEventMask = HCCL_ASSERT_EVENT_MASK;
545 0 : cfg.DeassertEventMask = HCCL_DEASSERT_EVENT_MASK;
546 :
547 0 : auto const sRet = snprintf_s(cfg.name, sizeof(cfg.name), sizeof(cfg.name) - 1U, "hccl_%d", getpid());
548 0 : if (sRet <= 0) {
549 0 : HCCL_ERROR("[CannErrorReporter][ConstructSensorNodeCfg] sprintf_s name err, ret[%d].", sRet);
550 0 : return HCCL_E_INTERNAL;
551 : }
552 :
553 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalSensorNodeRegister(devId, &cfg, handle);
554 0 : CHK_PRT_RET(
555 : ret != DRV_ERROR_NONE,
556 : HCCL_ERROR(
557 : "[hrtHalSensorNodeRegister]errNo[0x%016llx]"
558 : "hrtHalSensorNodeRegister fail, return[%d], para: devid[%u], nodeName[%s], nodeType[%u], sensorType[%u].",
559 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devId, cfg.name, cfg.NodeType, cfg.SensorType),
560 : HCCL_E_DRV);
561 :
562 0 : return HCCL_SUCCESS;
563 : #else
564 : HCCL_ERROR("[halSensorNodeRegister]Does not support this interface.");
565 : return HCCL_E_NOT_SUPPORT;
566 : #endif
567 : }
568 :
569 0 : HcclResult hrtHalSensorNodeUnregister([[maybe_unused]] uint32_t devId, [[maybe_unused]] uint64_t handle)
570 : {
571 : #ifdef CCL_KERNEL
572 0 : if (DlHalFunction::GetInstance().dlHalSensorNodeUnregister == nullptr) {
573 0 : HCCL_ERROR("dlHalSensorNodeUnregister is nullptr, can not use dlHalSensorNodeUnregister");
574 0 : return HCCL_E_DRV;
575 : }
576 :
577 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalSensorNodeUnregister(devId, handle);
578 0 : CHK_PRT_RET(
579 : ret != DRV_ERROR_NONE,
580 : HCCL_ERROR(
581 : "[hrtHalSensorNodeUnregister]errNo[0x%016llx]"
582 : "hrtHalSensorNodeUnregister fail, return[%d], para: devid[%u], handle[%llu].",
583 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devId, handle),
584 : HCCL_E_DRV);
585 :
586 0 : return HCCL_SUCCESS;
587 : #else
588 : HCCL_ERROR("[halSensorNodeUnregister]Does not support this interface.");
589 : return HCCL_E_NOT_SUPPORT;
590 : #endif
591 : }
592 0 : halGeneralEventType_t TranslateEventType(HcclGeneralEventType assertion)
593 : {
594 0 : switch (assertion) {
595 0 : case HcclGeneralEventType::HCCL_GENERAL_EVENT_TYPE_RESUME:
596 0 : return GENERAL_EVENT_TYPE_RESUME;
597 :
598 0 : case HcclGeneralEventType::HCCL_GENERAL_EVENT_TYPE_OCCUR:
599 0 : return GENERAL_EVENT_TYPE_OCCUR;
600 :
601 0 : case HcclGeneralEventType::HCCL_GENERAL_EVENT_TYPE_ONE_TIME:
602 0 : return GENERAL_EVENT_TYPE_ONE_TIME;
603 :
604 0 : case HcclGeneralEventType::HCCL_GENERAL_EVENT_TYPE_MAX:
605 0 : return GENERAL_EVENT_TYPE_MAX;
606 :
607 0 : default: {
608 0 : HCCL_ERROR("[TranslateEventType]Not support the General Event type[%d].", assertion);
609 0 : return GENERAL_EVENT_TYPE_MAX;
610 : }
611 : }
612 : }
613 :
614 0 : HcclResult hrtHalSensorNodeUpdateState(
615 : [[maybe_unused]] uint32_t devId, [[maybe_unused]] uint64_t handle, [[maybe_unused]] int val,
616 : [[maybe_unused]] HcclGeneralEventType assertion)
617 : {
618 : #ifdef CCL_KERNEL
619 0 : if (DlHalFunction::GetInstance().dlHalSensorNodeUpdateState == nullptr) {
620 0 : HCCL_ERROR("dlHalSensorNodeUpdateState is nullptr, can not use dlHalSensorNodeUpdateState");
621 0 : return HCCL_E_DRV;
622 : }
623 :
624 0 : halGeneralEventType_t type = TranslateEventType(assertion);
625 0 : drvError_t ret = DlHalFunction::GetInstance().dlHalSensorNodeUpdateState(devId, handle, val, type);
626 0 : CHK_PRT_RET(
627 : ret != DRV_ERROR_NONE,
628 : HCCL_RUN_WARNING(
629 : "[hrtHalSensorNodeUpdateState]errNo[0x%016llx]"
630 : "hrtHalSensorNodeUpdateState fail, return[%d], para: devid[%u], handle[%llu], val[%d], assertion[%u].",
631 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, devId, handle, val, assertion),
632 : HCCL_E_DRV);
633 :
634 0 : return HCCL_SUCCESS;
635 : #else
636 : HCCL_ERROR("[halSensorNodeUpdateState]Does not support this interface.");
637 : return HCCL_E_NOT_SUPPORT;
638 : #endif
639 : }
640 :
641 531 : HcclResult hrtHalGetDeviceType(const uint32_t devId, DevType& devType)
642 : {
643 531 : if (UNLIKELY(!hccl::DlHalFunction::GetInstance().DlHalFunctionIsInit())) {
644 0 : CHK_RET(DlHalFunction::GetInstance().DlHalFunctionInit());
645 : }
646 :
647 531 : std::string chipName;
648 531 : HcclResult ret = hrtHalGetChipInfo(devId, chipName);
649 531 : if (ret != HCCL_SUCCESS) {
650 0 : HCCL_ERROR("hrtHalGetChipInfo failed, ret[%d], devId[%u]", ret, devId);
651 0 : devType = DevType::DEV_TYPE_COUNT;
652 0 : return ret;
653 : }
654 531 : HCCL_INFO("[Get][DeviceType]Chip name[%s].", chipName.c_str());
655 :
656 531 : if (chipName.find("Ascend950") != std::string::npos) {
657 0 : devType = DevType::DEV_TYPE_950;
658 0 : return HCCL_SUCCESS;
659 : }
660 :
661 1062 : if (chipName.find("Ascend910_96") != std::string::npos || chipName.find("Ascend960") != std::string::npos
662 1062 : || chipName.find("ascend960") != std::string::npos) {
663 0 : devType = DevType::DEV_TYPE_960;
664 0 : return HCCL_SUCCESS;
665 : }
666 :
667 531 : auto iter = SOC_VER_CONVERT.find(chipName);
668 531 : if (iter == SOC_VER_CONVERT.end()) {
669 0 : HCCL_ERROR(
670 : "[Get][DeviceType]errNo[0x%016llx] hrtHalGetChipInfo get illegal chipver, chipName[%s].",
671 : HCCL_ERROR_CODE(HCCL_E_DRV), chipName.c_str());
672 0 : devType = DevType::DEV_TYPE_COUNT;
673 0 : return HCCL_E_DRV;
674 : }
675 531 : devType = iter->second;
676 :
677 531 : HCCL_INFO("[Get][DeviceType]deviceId[%u] get devType[%d] success!", devId, devType);
678 531 : return HCCL_SUCCESS;
679 531 : }
680 :
681 1 : HcclResult GetRunSideIsDevice(bool& isDeviceSide)
682 : {
683 : static bool deviceSide = false;
684 : static bool init = false;
685 1 : if (UNLIKELY(!init)) {
686 1 : if (UNLIKELY(!hccl::DlHalFunction::GetInstance().DlHalFunctionIsInit())) {
687 0 : CHK_RET(DlHalFunction::GetInstance().DlHalFunctionInit());
688 : }
689 1 : u32 info = 0;
690 1 : CHK_RET(hrtDrvGetPlatformInfo(&info));
691 1 : deviceSide = info == 0 ? true : false;
692 1 : init = true;
693 : }
694 :
695 1 : isDeviceSide = deviceSide;
696 1 : return HCCL_SUCCESS;
697 : }
698 :
699 22 : HcclResult CheckRunSideIsDevice()
700 : {
701 : static bool isDeviceSide = false;
702 : static bool init = false;
703 22 : if (UNLIKELY(!init)) {
704 1 : CHK_RET(GetRunSideIsDevice(isDeviceSide));
705 1 : init = true;
706 : }
707 22 : if (UNLIKELY(!isDeviceSide)) {
708 0 : HCCL_ERROR("currently running on host");
709 0 : return HCCL_E_INTERNAL;
710 : }
711 22 : return HCCL_SUCCESS;
712 : }
713 : extern "C" {
714 : drvError_t __attribute__((weak)) drvGetLocalDevIDByHostDevID(uint32_t host_dev_id, uint32_t* local_dev_id);
715 : drvError_t __attribute__((weak)) drvMemSmmuQuery(DVdevice device, uint32_t* SSID);
716 : int32_t __attribute__((weak)) StartMC2MaintenanceThread(mc2Funcs f1, void* p1, mc2Funcs f2, void* p2);
717 : int32_t __attribute__((weak)) AicpuCreateCtrlThread(uint32_t type, mc2Funcs f1, void* p1, mc2Funcs f2, void* p2);
718 : };
719 :
720 178 : HcclResult hrtDrvGetLocalDevIDByHostDevID(u32 hostUdevid, u32* localDevid)
721 : {
722 178 : CHK_PTR_NULL(drvGetLocalDevIDByHostDevID);
723 178 : CHK_PTR_NULL(localDevid);
724 :
725 178 : drvError_t ret = drvGetLocalDevIDByHostDevID(hostUdevid, localDevid);
726 178 : CHK_PRT_RET(
727 : ret != DRV_ERROR_NONE,
728 : HCCL_ERROR(
729 : "[hrtDrvGetLocalDevIDByHostDevID]errNo[0x%016llx]"
730 : "hrtDrvGetLocalDevIDByHostDevID fail, return[%d], para: hostUdevid[%u] localDevid[%p].",
731 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, hostUdevid, localDevid),
732 : HCCL_E_DRV);
733 178 : return HCCL_SUCCESS;
734 : }
735 :
736 0 : HcclResult hrtDrvMemSmmuQuery(uint32_t localDevid, uint32_t* SSID)
737 : {
738 0 : CHK_PTR_NULL(drvMemSmmuQuery);
739 0 : CHK_PTR_NULL(SSID);
740 :
741 0 : drvError_t ret = drvMemSmmuQuery(localDevid, SSID);
742 0 : CHK_PRT_RET(
743 : ret != DRV_ERROR_NONE,
744 : HCCL_ERROR(
745 : "[hrtDrvMemSmmuQuery]errNo[0x%016llx]"
746 : "hrtDrvMemSmmuQuery fail, return[%d], para: localDevid[%u] SSID[%p].",
747 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, localDevid, SSID),
748 : HCCL_E_DRV);
749 0 : return HCCL_SUCCESS;
750 : }
751 :
752 779 : bool IsSupportStartMC2MaintenanceThread()
753 : {
754 779 : return StartMC2MaintenanceThread != nullptr || AicpuCreateCtrlThread != nullptr;
755 : }
756 :
757 140 : HcclResult hrtHalStartMC2MaintenanceThread(mc2Funcs f1, void* p1, mc2Funcs f2, void* p2)
758 : {
759 140 : CHK_PTR_NULL(f1);
760 140 : CHK_PTR_NULL(p1);
761 140 : CHK_PTR_NULL(f2);
762 140 : CHK_PTR_NULL(p2);
763 :
764 140 : int ret = 0;
765 :
766 140 : if (AicpuCreateCtrlThread != nullptr) {
767 140 : HCCL_INFO("[hrtHalStartMC2MaintenanceThread] AicpuCreateCtrlThread");
768 140 : ret = AicpuCreateCtrlThread(THREAD_TYPE_HCOM, f1, p1, f2, p2);
769 140 : CHK_PRT_RET(
770 : (ret != 0 && ret != AICPU_SCHEDULE_THREAD_ALREADY_EXISTS),
771 : HCCL_ERROR(
772 : "[AicpuCreateCtrlThread]errNo[0x%016llx]"
773 : "AicpuCreateCtrlThread fail, return[%d], para: mc2Funcs f1[%p] p1[%p], mc2Funcs f2[%p] p2[%p].",
774 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, f1, p1, f2, p2),
775 : HCCL_E_DRV);
776 0 : } else if (StartMC2MaintenanceThread != nullptr) {
777 0 : HCCL_INFO("[hrtHalStartMC2MaintenanceThread] StartMC2MaintenanceThread");
778 0 : ret = StartMC2MaintenanceThread(f1, p1, f2, p2);
779 0 : CHK_PRT_RET(
780 : (ret != 0 && ret != AICPU_SCHEDULE_THREAD_ALREADY_EXISTS),
781 : HCCL_ERROR(
782 : "[StartMC2MaintenanceThread]errNo[0x%016llx]"
783 : "StartMC2MaintenanceThread fail, return[%d], para: mc2Funcs f1[%p] p1[%p], mc2Funcs f2[%p] p2[%p].",
784 : HCCL_ERROR_CODE(HCCL_E_DRV), ret, f1, p1, f2, p2),
785 : HCCL_E_DRV);
786 : } else {
787 0 : HCCL_ERROR(
788 : "[hrtHalStartMC2MaintenanceThread] AicpuCreateCtrlThread and StartMC2MaintenanceThread are both nullptr");
789 0 : return HCCL_E_DRV;
790 : }
791 140 : return HCCL_SUCCESS;
792 : }
793 :
794 4809 : HcclResult hrtHalResourceIdRestore(u32 devId, u32 tsId, drvIdType_t resType, u32 resId, u32 flag)
795 : {
796 : // 兼容老的12包，找不到符号时不报错，返回HCCL_E_NOT_SUPPORT由上层处理是否报错
797 4809 : CHK_PRT_RET(
798 : halResourceIdRestore == nullptr,
799 : HCCL_WARNING("hrtHalResourceIdRestore not support, halResourceIdRestore is nullptr"), HCCL_E_NOT_SUPPORT);
800 :
801 4809 : drvResIdKey resInfo = {};
802 4809 : resInfo.ruDevId = devId;
803 4809 : resInfo.tsId = tsId;
804 4809 : resInfo.resType = resType;
805 4809 : resInfo.resId = resId;
806 4809 : resInfo.flag = flag;
807 :
808 4809 : int checkResult = halResourceIdRestore(&resInfo);
809 4809 : if (checkResult != 0) {
810 0 : HCCL_ERROR(
811 : "[drv api]res restore failed, result:%d, resType:%d, resId:%u, tsId:%u, ruDevId:%u, flag:%u", checkResult,
812 : resInfo.resType, resInfo.resId, resInfo.tsId, resInfo.ruDevId, resInfo.flag);
813 0 : return HCCL_E_DRV;
814 : }
815 :
816 4809 : HCCL_INFO(
817 : "res restore success, resType:%d, resId:%u, tsId:%u, ruDevId:%u, flag:%u", resInfo.resType, resInfo.resId,
818 : resInfo.tsId, resInfo.ruDevId, resInfo.flag);
819 4809 : return HCCL_SUCCESS;
820 : }
|
