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