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 "utils/cann_info_utils.h"
12 : #include "utils/data_type_utils.h"
13 :
14 : #include <fstream>
15 : #include <sys/stat.h>
16 : #include "acl_rt_impl.h"
17 : #include "utils/file_utils.h"
18 : #include "common/json_parser.h"
19 :
20 : namespace acl {
21 : namespace {
22 : #if defined(ONLY_ENABLE_ACL_UT)
23 : constexpr const char_t* const SW_CONFIG_FILE = "tmp_run_data/ascendcl_config/swFeatureList.json";
24 : constexpr const char_t* const RUNTIME_VERSION_PATH = "tests/tmp_run_data/share/info/runtime/version.info";
25 : #else
26 : constexpr const char_t* const SW_CONFIG_FILE = "data/ascendcl_config/swFeatureList.json";
27 : constexpr const char_t* const RUNTIME_VERSION_PATH = "share/info/runtime/version.info";
28 : #endif
29 : constexpr const char_t* const VERSION_INFO_KEY = "Version=";
30 : constexpr size_t MAX_INSTALL_PATH_SEARCH_DEPTH = 8U;
31 :
32 12 : std::string StripTrailingSlash(const std::string& path)
33 : {
34 12 : if ((path.size() > 1UL) && (path.back() == '/')) {
35 12 : return path.substr(0, path.size() - 1UL);
36 : }
37 0 : return path;
38 : }
39 :
40 12 : std::string GetParentDir(const std::string& path)
41 : {
42 12 : const std::string strippedPath = StripTrailingSlash(path);
43 12 : const size_t pos = strippedPath.rfind('/');
44 12 : if (pos == std::string::npos) {
45 0 : return "";
46 : }
47 12 : return strippedPath.substr(0, pos + 1UL);
48 12 : }
49 :
50 27 : bool IsRegularFile(const std::string& path)
51 : {
52 27 : struct stat fileStat = {};
53 27 : return (stat(path.c_str(), &fileStat) == 0) && S_ISREG(fileStat.st_mode);
54 : }
55 :
56 3 : bool FindFileFromCurrentToParents(const std::string& startDir, const std::string& relativePath, std::string& matchedDir)
57 : {
58 3 : std::string currentDir = startDir;
59 15 : for (size_t depth = 0U; depth < MAX_INSTALL_PATH_SEARCH_DEPTH; ++depth) {
60 15 : if (currentDir.empty()) {
61 3 : return false;
62 : }
63 15 : if (IsRegularFile(currentDir + relativePath)) {
64 3 : matchedDir = currentDir;
65 3 : return true;
66 : }
67 12 : const std::string parentDir = GetParentDir(currentDir);
68 12 : if ((parentDir.empty()) || (parentDir == currentDir)) {
69 0 : return false;
70 : }
71 12 : currentDir = parentDir;
72 12 : }
73 0 : return false;
74 3 : }
75 : } // namespace
76 :
77 : std::mutex CannInfoUtils::mutex_;
78 : bool CannInfoUtils::initFlag_ = false;
79 : int32_t CannInfoUtils::currentRuntimeVersion_ = UNKNOWN_VERSION;
80 : std::string CannInfoUtils::swConfigPath_;
81 : std::string CannInfoUtils::defaultInstallPath_;
82 : aclCannAttr CannInfoUtils::attrArray_[MAX_CANN_ATTR_SIZE];
83 : size_t CannInfoUtils::attrNum_ = 0;
84 :
85 : std::map<aclCannAttr, CannInfo> CannInfoUtils::attrToCannInfo_ = {
86 : {ACL_CANN_ATTR_INF_NAN, CannInfo("INF_NAN", "SoCInfo", "support_inf_nan")},
87 : {ACL_CANN_ATTR_BF16, CannInfo("BF16", "SoCInfo", "support_bf16")},
88 : {ACL_CANN_ATTR_JIT_COMPILE, CannInfo("JIT_COMPILE", "", "")},
89 : };
90 :
91 3 : aclError CannInfoUtils::GetAttributeList(const aclCannAttr** cannAttr, size_t* num)
92 : {
93 3 : const aclError ret = Initialize();
94 3 : if (ret != ACL_SUCCESS) {
95 2 : ACL_LOG_INNER_ERROR("initialize CannInfoUtils failed, ret = %d", static_cast<int32_t>(ret));
96 2 : return ret;
97 : }
98 1 : *cannAttr = attrArray_;
99 1 : *num = attrNum_;
100 1 : return ACL_SUCCESS;
101 : }
102 :
103 10 : aclError CannInfoUtils::GetAttribute(aclCannAttr cannAttr, int32_t* value)
104 : {
105 10 : const aclError ret = Initialize();
106 10 : if (ret != ACL_SUCCESS) {
107 7 : ACL_LOG_INNER_ERROR("initialize CannInfoUtils failed, ret = %d", static_cast<int32_t>(ret));
108 7 : return ret;
109 : }
110 :
111 3 : auto iter = attrToCannInfo_.find(cannAttr);
112 3 : if (iter == attrToCannInfo_.end()) {
113 1 : ACL_LOG_WARN("find cann attr failed, attr value = %s", acl::GetCannAttrDesc(cannAttr));
114 1 : return ACL_ERROR_INVALID_PARAM;
115 : }
116 2 : *value = iter->second.isAvailable;
117 2 : return ACL_SUCCESS;
118 : }
119 :
120 13 : aclError CannInfoUtils::Initialize()
121 : {
122 13 : std::lock_guard<std::mutex> lock(mutex_);
123 13 : if (initFlag_) {
124 3 : ACL_LOG_INFO("CannInfoUtils has already initialized.");
125 3 : return ACL_SUCCESS;
126 : }
127 10 : ACL_LOG_INFO("Start to initialize CannInfoUtils.");
128 : // init config path and CANN install path
129 10 : auto ret = GetConfigInstallPath();
130 10 : if (ret != ACL_SUCCESS) {
131 4 : ACL_LOG_INNER_ERROR("Failed to get swFeatureList.json, please check ascendcl_config path.");
132 4 : return ret;
133 : }
134 :
135 : // parse requirments of each attributes
136 6 : ret = JsonParser::GetAttrConfigFromFile(swConfigPath_.c_str(), attrToCannInfo_);
137 6 : if (ret != ACL_SUCCESS) {
138 0 : ACL_LOG_INNER_ERROR("Failed to parse requirements of Cann attrs, ret = %d.", ret);
139 0 : return ret;
140 : }
141 :
142 : // parse current CannInfo
143 6 : const std::string runtimeVersionPath = defaultInstallPath_ + RUNTIME_VERSION_PATH;
144 6 : ret = ParseVersionInfo(runtimeVersionPath, ¤tRuntimeVersion_);
145 6 : if (ret != ACL_SUCCESS) {
146 5 : ACL_LOG_WARN("cannot get runtime version in current environment!");
147 5 : return ACL_ERROR_INTERNAL_ERROR;
148 : }
149 :
150 : // check and update attr availability
151 1 : CheckAndUpdateAttrAvailability();
152 1 : initFlag_ = true;
153 1 : ACL_LOG_INFO(
154 : "Successfully initialized CannInfoUtils: current CannInfo[runtime = %d, attrNum = %zu]", currentRuntimeVersion_,
155 : attrNum_);
156 :
157 1 : return ACL_SUCCESS;
158 13 : }
159 :
160 10 : aclError CannInfoUtils::GetConfigInstallPath()
161 : {
162 10 : std::string path;
163 10 : const aclError ret = file_utils::GetSoRealPath(path);
164 10 : if (ret != ACL_SUCCESS) {
165 4 : ACL_LOG_WARN("Failed to get libascendcl.so file path.");
166 4 : return ret;
167 : }
168 6 : ACL_LOG_DEBUG("current path = %s", path.c_str());
169 6 : const std::string soDir = path;
170 6 : path = path.substr(0, path.rfind('/'));
171 6 : path = path.substr(0, path.rfind('/') + 1UL);
172 6 : swConfigPath_ = path + SW_CONFIG_FILE;
173 6 : if (!IsRegularFile(swConfigPath_)) {
174 1 : std::string matchedDir;
175 2 : if (FindFileFromCurrentToParents(soDir, SW_CONFIG_FILE, matchedDir)) {
176 1 : swConfigPath_ = matchedDir + SW_CONFIG_FILE;
177 1 : path = matchedDir;
178 1 : ACL_LOG_INFO("fallback to swConfigPath = %s", swConfigPath_.c_str());
179 : }
180 1 : }
181 6 : ACL_LOG_DEBUG("swConfigPath = %s", swConfigPath_.c_str());
182 6 : path.pop_back();
183 6 : defaultInstallPath_ = path.substr(0, path.rfind('/') + 1UL);
184 6 : if (!IsRegularFile(defaultInstallPath_ + RUNTIME_VERSION_PATH)) {
185 2 : std::string matchedDir;
186 4 : if (FindFileFromCurrentToParents(soDir, RUNTIME_VERSION_PATH, matchedDir)) {
187 2 : defaultInstallPath_ = matchedDir;
188 2 : ACL_LOG_INFO("fallback to defaultInstallPath = %s", defaultInstallPath_.c_str());
189 : }
190 2 : }
191 6 : ACL_LOG_DEBUG("defaultInstallPath = %s", defaultInstallPath_.c_str());
192 6 : return ACL_SUCCESS;
193 10 : }
194 :
195 6 : aclError CannInfoUtils::ParseVersionInfo(const std::string& path, int32_t* version)
196 : {
197 6 : std::ifstream ifs(path, std::ifstream::in);
198 6 : if (!ifs.is_open()) {
199 0 : ACL_LOG_WARN("Open file [%s] failed.", path.c_str());
200 0 : return ACL_ERROR_INTERNAL_ERROR;
201 : }
202 6 : std::string line;
203 7 : while (std::getline(ifs, line)) {
204 4 : if (line.find(VERSION_INFO_KEY) != std::string::npos) {
205 3 : ACL_LOG_DEBUG("Parse version success, content is [%s].", line.c_str());
206 3 : ifs.close();
207 3 : const size_t prefixLen = strlen(VERSION_INFO_KEY);
208 3 : line = line.substr(prefixLen);
209 3 : const size_t pos = line.find('.', line.find('.') + 1UL);
210 3 : line = line.substr(0, pos);
211 3 : return ParseVersionValue(line, version);
212 : }
213 : }
214 3 : ifs.close();
215 3 : ACL_LOG_WARN("cannot find valid Version info, please check path = %s", path.c_str());
216 3 : return ACL_ERROR_INTERNAL_ERROR;
217 6 : }
218 :
219 17 : aclError CannInfoUtils::ParseVersionValue(const std::string& str, int32_t* value)
220 : {
221 17 : const size_t pos = str.find('.');
222 : try {
223 19 : const int32_t major = std::stoi(str.substr(0, pos));
224 15 : const int32_t minor = std::stoi(str.substr(pos + 1UL));
225 15 : *value = 1000 * major + 10 * minor;
226 2 : } catch (...) {
227 2 : ACL_LOG_WARN("strVal[%s] can not be converted to version value", str.c_str());
228 2 : return ACL_ERROR_INTERNAL_ERROR;
229 2 : }
230 15 : return ACL_SUCCESS;
231 : }
232 :
233 3 : bool CannInfoUtils::MatchVersionInfo(const CannInfo& configCannInfo)
234 : {
235 : // if version is not set, skip matching and return true
236 3 : if (configCannInfo.minimumRuntimeVersion == UNKNOWN_VERSION) {
237 0 : return true;
238 : }
239 3 : return (currentRuntimeVersion_ >= configCannInfo.minimumRuntimeVersion);
240 : }
241 :
242 3 : bool CannInfoUtils::CheckNPUFeatures(const CannInfo& configInfo)
243 : {
244 3 : if (configInfo.socSpecLabel.empty() || configInfo.socSpecKey.empty()) {
245 : // label 或 key 为空说明特性与芯片无关, 无需查询
246 1 : return true;
247 : }
248 2 : constexpr uint32_t kMaxValueLen = 16U;
249 2 : char_t value[kMaxValueLen] = {0};
250 2 : const auto ret = rtGetSocSpec(configInfo.socSpecLabel.c_str(), configInfo.socSpecKey.c_str(), value, kMaxValueLen);
251 2 : if (ret != RT_ERROR_NONE) {
252 0 : ACL_LOG_WARN(
253 : "Cannot get platform info, label = [%s], key = [%s]", configInfo.socSpecLabel.c_str(),
254 : configInfo.socSpecKey.c_str());
255 0 : return false;
256 : }
257 : // value "0" 或空 或非法内容 都认为 false
258 2 : const std::string strVal(value);
259 2 : return strVal == "1";
260 2 : }
261 :
262 1 : void CannInfoUtils::CheckAndUpdateAttrAvailability()
263 : {
264 4 : for (auto& item : attrToCannInfo_) {
265 3 : auto& swConfigInfo = item.second;
266 3 : if (MatchVersionInfo(swConfigInfo) && CheckNPUFeatures(swConfigInfo)) {
267 3 : ACL_LOG_INFO("support cann attribute [%s]", swConfigInfo.readableAttrName.c_str());
268 3 : swConfigInfo.isAvailable = 1;
269 3 : attrArray_[attrNum_] = item.first;
270 3 : ++attrNum_;
271 : }
272 : }
273 1 : }
274 :
275 48 : const char* GetDataTypeDesc(aclDataType type)
276 : {
277 48 : switch (type) {
278 2 : case ACL_DT_UNDEFINED:
279 2 : return "DT_UNDEFINED(-1)";
280 2 : case ACL_FLOAT:
281 2 : return "FLOAT(0)";
282 2 : case ACL_FLOAT16:
283 2 : return "FLOAT16(1)";
284 5 : case ACL_INT8:
285 5 : return "INT8(2)";
286 2 : case ACL_INT32:
287 2 : return "INT32(3)";
288 2 : case ACL_UINT8:
289 2 : return "UINT8(4)";
290 2 : case ACL_INT16:
291 2 : return "INT16(6)";
292 2 : case ACL_UINT16:
293 2 : return "UINT16(7)";
294 2 : case ACL_UINT32:
295 2 : return "UINT32(8)";
296 4 : case ACL_INT64:
297 4 : return "INT64(9)";
298 1 : case ACL_UINT64:
299 1 : return "UINT64(10)";
300 1 : case ACL_DOUBLE:
301 1 : return "DOUBLE(11)";
302 3 : case ACL_BOOL:
303 3 : return "BOOL(12)";
304 1 : case ACL_STRING:
305 1 : return "STRING(13)";
306 1 : case ACL_COMPLEX64:
307 1 : return "COMPLEX64(16)";
308 1 : case ACL_COMPLEX128:
309 1 : return "COMPLEX128(17)";
310 2 : case ACL_BF16:
311 2 : return "BF16(27)";
312 2 : case ACL_INT4:
313 2 : return "INT4(29)";
314 1 : case ACL_UINT1:
315 1 : return "UINT1(30)";
316 1 : case ACL_COMPLEX32:
317 1 : return "COMPLEX32(33)";
318 1 : case ACL_HIFLOAT8:
319 1 : return "HIFLOAT8(34)";
320 1 : case ACL_FLOAT8_E5M2:
321 1 : return "FLOAT8_E5M2(35)";
322 1 : case ACL_FLOAT8_E4M3FN:
323 1 : return "FLOAT8_E4M3FN(36)";
324 1 : case ACL_FLOAT8_E8M0:
325 1 : return "FLOAT8_E8M0(37)";
326 1 : case ACL_FLOAT6_E3M2:
327 1 : return "FLOAT6_E3M2(38)";
328 1 : case ACL_FLOAT6_E2M3:
329 1 : return "FLOAT6_E2M3(39)";
330 1 : case ACL_FLOAT4_E2M1:
331 1 : return "FLOAT4_E2M1(40)";
332 1 : case ACL_FLOAT4_E1M2:
333 1 : return "FLOAT4_E1M2(41)";
334 1 : default:
335 1 : break;
336 : }
337 : static thread_local char enumBuf[32];
338 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(type));
339 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
340 1 : return enumBuf;
341 : }
342 :
343 106 : const char* GetMemcpyKindDesc(aclrtMemcpyKind kind)
344 : {
345 106 : switch (kind) {
346 17 : case ACL_MEMCPY_HOST_TO_HOST:
347 17 : return "MEMCPY_HOST_TO_HOST(0)";
348 34 : case ACL_MEMCPY_HOST_TO_DEVICE:
349 34 : return "MEMCPY_HOST_TO_DEVICE(1)";
350 6 : case ACL_MEMCPY_DEVICE_TO_HOST:
351 6 : return "MEMCPY_DEVICE_TO_HOST(2)";
352 5 : case ACL_MEMCPY_DEVICE_TO_DEVICE:
353 5 : return "MEMCPY_DEVICE_TO_DEVICE(3)";
354 6 : case ACL_MEMCPY_DEFAULT:
355 6 : return "MEMCPY_DEFAULT(4)";
356 8 : case ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE:
357 8 : return "MEMCPY_HOST_TO_BUF_TO_DEVICE(5)";
358 1 : case ACL_MEMCPY_INNER_DEVICE_TO_DEVICE:
359 1 : return "MEMCPY_INNER_DEVICE_TO_DEVICE(6)";
360 1 : case ACL_MEMCPY_INTER_DEVICE_TO_DEVICE:
361 1 : return "MEMCPY_INTER_DEVICE_TO_DEVICE(7)";
362 28 : default:
363 28 : break;
364 : }
365 : static thread_local char enumBuf[32];
366 28 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(kind));
367 28 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
368 28 : return enumBuf;
369 : }
370 :
371 47 : const char* GetMemAttrDesc(aclrtMemAttr attr)
372 : {
373 47 : switch (attr) {
374 3 : case ACL_DDR_MEM:
375 3 : return "DDR_MEM(0)";
376 5 : case ACL_HBM_MEM:
377 5 : return "HBM_MEM(1)";
378 11 : case ACL_DDR_MEM_HUGE:
379 11 : return "DDR_MEM_HUGE(2)";
380 5 : case ACL_DDR_MEM_NORMAL:
381 5 : return "DDR_MEM_NORMAL(3)";
382 1 : case ACL_HBM_MEM_HUGE:
383 1 : return "HBM_MEM_HUGE(4)";
384 1 : case ACL_HBM_MEM_NORMAL:
385 1 : return "HBM_MEM_NORMAL(5)";
386 3 : case ACL_DDR_MEM_P2P_HUGE:
387 3 : return "DDR_MEM_P2P_HUGE(6)";
388 3 : case ACL_DDR_MEM_P2P_NORMAL:
389 3 : return "DDR_MEM_P2P_NORMAL(7)";
390 1 : case ACL_HBM_MEM_P2P_HUGE:
391 1 : return "HBM_MEM_P2P_HUGE(8)";
392 3 : case ACL_HBM_MEM_P2P_NORMAL:
393 3 : return "HBM_MEM_P2P_NORMAL(9)";
394 1 : case ACL_HBM_MEM_HUGE1G:
395 1 : return "HBM_MEM_HUGE1G(10)";
396 3 : case ACL_HBM_MEM_P2P_HUGE1G:
397 3 : return "HBM_MEM_P2P_HUGE1G(11)";
398 1 : case ACL_MEM_NORMAL:
399 1 : return "MEM_NORMAL(12)";
400 1 : case ACL_MEM_HUGE:
401 1 : return "MEM_HUGE(13)";
402 1 : case ACL_MEM_HUGE1G:
403 1 : return "MEM_HUGE1G(14)";
404 1 : case ACL_MEM_P2P_NORMAL:
405 1 : return "MEM_P2P_NORMAL(15)";
406 1 : case ACL_MEM_P2P_HUGE:
407 1 : return "MEM_P2P_HUGE(16)";
408 1 : case ACL_MEM_P2P_HUGE1G:
409 1 : return "MEM_P2P_HUGE1G(17)";
410 1 : default:
411 1 : break;
412 : }
413 : static thread_local char enumBuf[32];
414 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(attr));
415 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
416 1 : return enumBuf;
417 : }
418 :
419 14 : const char* GetCannAttrDesc(aclCannAttr attr)
420 : {
421 14 : switch (attr) {
422 3 : case ACL_CANN_ATTR_UNDEFINED:
423 3 : return "CANN_ATTR_UNDEFINED(-1)";
424 8 : case ACL_CANN_ATTR_INF_NAN:
425 8 : return "CANN_ATTR_INF_NAN(0)";
426 1 : case ACL_CANN_ATTR_BF16:
427 1 : return "CANN_ATTR_BF16(1)";
428 1 : case ACL_CANN_ATTR_JIT_COMPILE:
429 1 : return "CANN_ATTR_JIT_COMPILE(2)";
430 1 : default:
431 1 : break;
432 : }
433 : static thread_local char enumBuf[32];
434 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(attr));
435 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
436 1 : return enumBuf;
437 : }
438 :
439 15 : const char* GetDevResLimitTypeDesc(aclrtDevResLimitType type)
440 : {
441 15 : switch (type) {
442 13 : case ACL_RT_DEV_RES_CUBE_CORE:
443 13 : return "RT_DEV_RES_CUBE_CORE(0)";
444 1 : case ACL_RT_DEV_RES_VECTOR_CORE:
445 1 : return "RT_DEV_RES_VECTOR_CORE(1)";
446 1 : default:
447 1 : break;
448 : }
449 : static thread_local char enumBuf[32];
450 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(type));
451 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
452 1 : return enumBuf;
453 : }
454 :
455 20 : const char* GetReduceKindDesc(aclrtReduceKind kind)
456 : {
457 20 : switch (kind) {
458 16 : case ACL_RT_MEMCPY_SDMA_AUTOMATIC_SUM:
459 16 : return "RT_MEMCPY_SDMA_AUTOMATIC_SUM(10)";
460 1 : case ACL_RT_MEMCPY_SDMA_AUTOMATIC_MAX:
461 1 : return "RT_MEMCPY_SDMA_AUTOMATIC_MAX(11)";
462 1 : case ACL_RT_MEMCPY_SDMA_AUTOMATIC_MIN:
463 1 : return "RT_MEMCPY_SDMA_AUTOMATIC_MIN(12)";
464 1 : case ACL_RT_MEMCPY_SDMA_AUTOMATIC_EQUAL:
465 1 : return "RT_MEMCPY_SDMA_AUTOMATIC_EQUAL(13)";
466 1 : default:
467 1 : break;
468 : }
469 : static thread_local char enumBuf[32];
470 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(kind));
471 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
472 1 : return enumBuf;
473 : }
474 :
475 10 : const char* GetMemLinkTypeDesc(aclrtMemLinkType type)
476 : {
477 10 : switch (type) {
478 6 : case ACL_RT_MEM_ACCESS_LINK_SIO:
479 6 : return "RT_MEM_ACCESS_LINK_SIO(0)";
480 1 : case ACL_RT_MEM_ACCESS_LINK_HCCS:
481 1 : return "RT_MEM_ACCESS_LINK_HCCS(1)";
482 1 : case ACL_RT_MEM_ACCESS_UB_ONE_PORT_PATH:
483 1 : return "RT_MEM_ACCESS_UB_ONE_PORT_PATH(2)";
484 1 : case ACL_RT_MEM_ACCESS_UB_MULTI_PORT_PATH:
485 1 : return "RT_MEM_ACCESS_UB_MULTI_PORT_PATH(3)";
486 1 : default:
487 1 : break;
488 : }
489 : static thread_local char enumBuf[32];
490 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(type));
491 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
492 1 : return enumBuf;
493 : }
494 :
495 10 : const char* GetErrorTypeDesc(aclrtErrorType type)
496 : {
497 10 : switch (type) {
498 2 : case ACL_RT_NO_ERROR:
499 2 : return "RT_NO_ERROR(0)";
500 2 : case ACL_RT_ERROR_MEMORY:
501 2 : return "RT_ERROR_MEMORY(1)";
502 1 : case ACL_RT_ERROR_L2:
503 1 : return "RT_ERROR_L2(2)";
504 1 : case ACL_RT_ERROR_AICORE:
505 1 : return "RT_ERROR_AICORE(3)";
506 1 : case ACL_RT_ERROR_LINK:
507 1 : return "RT_ERROR_LINK(4)";
508 1 : case ACL_RT_ERROR_L3_PORT:
509 1 : return "RT_ERROR_L3_PORT(5)";
510 1 : case ACL_RT_ERROR_OTHERS:
511 1 : return "RT_ERROR_OTHERS(65535)";
512 1 : default:
513 1 : break;
514 : }
515 : static thread_local char enumBuf[32];
516 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(type));
517 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
518 1 : return enumBuf;
519 : }
520 :
521 10 : const char* GetStreamAttrDesc(aclrtStreamAttr attr)
522 : {
523 10 : switch (attr) {
524 5 : case ACL_STREAM_ATTR_FAILURE_MODE:
525 5 : return "STREAM_ATTR_FAILURE_MODE(1)";
526 1 : case ACL_STREAM_ATTR_FLOAT_OVERFLOW_CHECK:
527 1 : return "STREAM_ATTR_FLOAT_OVERFLOW_CHECK(2)";
528 1 : case ACL_STREAM_ATTR_USER_CUSTOM_TAG:
529 1 : return "STREAM_ATTR_USER_CUSTOM_TAG(3)";
530 1 : case ACL_STREAM_ATTR_CACHE_OP_INFO:
531 1 : return "STREAM_ATTR_CACHE_OP_INFO(4)";
532 1 : case ACL_STREAM_ATTR_PRIORITY:
533 1 : return "STREAM_ATTR_PRIORITY(5)";
534 1 : default:
535 1 : break;
536 : }
537 : static thread_local char enumBuf[32];
538 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(attr));
539 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
540 1 : return enumBuf;
541 : }
542 :
543 14 : const char* GetConditionDesc(aclrtCondition condition)
544 : {
545 14 : switch (condition) {
546 8 : case ACL_RT_EQUAL:
547 8 : return "RT_EQUAL(0)";
548 1 : case ACL_RT_NOT_EQUAL:
549 1 : return "RT_NOT_EQUAL(1)";
550 1 : case ACL_RT_GREATER:
551 1 : return "RT_GREATER(2)";
552 1 : case ACL_RT_GREATER_OR_EQUAL:
553 1 : return "RT_GREATER_OR_EQUAL(3)";
554 1 : case ACL_RT_LESS:
555 1 : return "RT_LESS(4)";
556 1 : case ACL_RT_LESS_OR_EQUAL:
557 1 : return "RT_LESS_OR_EQUAL(5)";
558 1 : default:
559 1 : break;
560 : }
561 : static thread_local char enumBuf[32];
562 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(condition));
563 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
564 1 : return enumBuf;
565 : }
566 :
567 10 : const char* GetCompareDataTypeDesc(aclrtCompareDataType type)
568 : {
569 10 : switch (type) {
570 8 : case ACL_RT_SWITCH_INT32:
571 8 : return "RT_SWITCH_INT32(0)";
572 1 : case ACL_RT_SWITCH_INT64:
573 1 : return "RT_SWITCH_INT64(1)";
574 1 : default:
575 1 : break;
576 : }
577 : static thread_local char enumBuf[32];
578 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(type));
579 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
580 1 : return enumBuf;
581 : }
582 :
583 4 : const char* GetIpcMemAttrTypeDesc(aclrtIpcMemAttrType type)
584 : {
585 4 : switch (type) {
586 3 : case ACL_RT_IPC_MEM_ATTR_ACCESS_LINK:
587 3 : return "RT_IPC_MEM_ATTR_ACCESS_LINK(0)";
588 1 : default:
589 1 : break;
590 : }
591 : static thread_local char enumBuf[32];
592 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(type));
593 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
594 1 : return enumBuf;
595 : }
596 :
597 8 : const char* GetFloatOverflowModeDesc(aclrtFloatOverflowMode mode)
598 : {
599 8 : switch (mode) {
600 4 : case ACL_RT_OVERFLOW_MODE_SATURATION:
601 4 : return "RT_OVERFLOW_MODE_SATURATION(0)";
602 1 : case ACL_RT_OVERFLOW_MODE_INFNAN:
603 1 : return "RT_OVERFLOW_MODE_INFNAN(1)";
604 2 : case ACL_RT_OVERFLOW_MODE_UNDEF:
605 2 : return "RT_OVERFLOW_MODE_UNDEF(2)";
606 1 : default:
607 1 : break;
608 : }
609 : static thread_local char enumBuf[32];
610 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(mode));
611 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
612 1 : return enumBuf;
613 : }
614 :
615 8 : const char* GetCmoTypeDesc(aclrtCmoType type)
616 : {
617 8 : switch (type) {
618 4 : case ACL_RT_CMO_TYPE_PREFETCH:
619 4 : return "RT_CMO_TYPE_PREFETCH(0)";
620 1 : case ACL_RT_CMO_TYPE_WRITEBACK:
621 1 : return "RT_CMO_TYPE_WRITEBACK(1)";
622 1 : case ACL_RT_CMO_TYPE_INVALID:
623 1 : return "RT_CMO_TYPE_INVALID(2)";
624 1 : case ACL_RT_CMO_TYPE_FLUSH:
625 1 : return "RT_CMO_TYPE_FLUSH(3)";
626 1 : default:
627 1 : break;
628 : }
629 : static thread_local char enumBuf[32];
630 1 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(type));
631 1 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
632 1 : return enumBuf;
633 : }
634 :
635 61 : const char* GetDeviceLimitDesc(aclrtDeviceLimit limit)
636 : {
637 61 : switch (limit) {
638 15 : case ACL_RT_DEV_LIMIT_SIMT_STACK_SIZE:
639 15 : return "RT_DEV_LIMIT_SIMT_STACK_SIZE(0)";
640 5 : case ACL_RT_DEV_LIMIT_SIMT_DVG_WARP_STACK_SIZE:
641 5 : return "RT_DEV_LIMIT_SIMT_DVG_WARP_STACK_SIZE(1)";
642 20 : case ACL_RT_DEV_LIMIT_SIMD_STACK_SIZE:
643 20 : return "RT_DEV_LIMIT_SIMD_STACK_SIZE(2)";
644 9 : case ACL_RT_DEV_LIMIT_SIMD_PRINTF_FIFO_SIZE_PER_CORE:
645 9 : return "RT_DEV_LIMIT_SIMD_PRINTF_FIFO_SIZE_PER_CORE(3)";
646 7 : case ACL_RT_DEV_LIMIT_SIMT_PRINTF_FIFO_SIZE:
647 7 : return "RT_DEV_LIMIT_SIMT_PRINTF_FIFO_SIZE(4)";
648 5 : default:
649 5 : break;
650 : }
651 : static thread_local char enumBuf[32];
652 5 : (void)snprintf_s(enumBuf, sizeof(enumBuf), sizeof(enumBuf) - 1, "UNKNOWN(%d)", static_cast<int32_t>(limit));
653 5 : enumBuf[sizeof(enumBuf) - 1U] = '\0';
654 5 : return enumBuf;
655 : }
656 : } // namespace acl
|
