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 "acl_rt_impl.h"
12 : #include <map>
13 : #include "runtime/kernel.h"
14 : #include "runtime/rts/rts_kernel.h"
15 : #include "runtime/rt_stars_define.h"
16 : #include "runtime/rts/rts_stars.h"
17 : #include "runtime/rts/rts_model.h"
18 : #include "common/log_inner.h"
19 : #include "common/error_codes_inner.h"
20 : #include "common/prof_reporter.h"
21 : #include "common/resource_statistics.h"
22 : namespace {
23 : static const std::map<aclDataType, rtRandomNumDataType> kMapDataType = {
24 : { ACL_INT32, RT_RANDOM_NUM_DATATYPE_INT32 },
25 : { ACL_INT64, RT_RANDOM_NUM_DATATYPE_INT64 },
26 : { ACL_UINT32, RT_RANDOM_NUM_DATATYPE_UINT32 },
27 : { ACL_UINT64, RT_RANDOM_NUM_DATATYPE_UINT64 },
28 : { ACL_BF16, RT_RANDOM_NUM_DATATYPE_BF16 },
29 : { ACL_FLOAT16, RT_RANDOM_NUM_DATATYPE_FP16 },
30 : { ACL_FLOAT, RT_RANDOM_NUM_DATATYPE_FP32 },
31 : };
32 : }
33 :
34 6 : aclrtBinary aclrtCreateBinaryImpl(const void *data, size_t dataLen)
35 : {
36 6 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_ALLOCATOR_BINARY_DESC);
37 6 : ACL_LOG_INFO("start to execute aclrtCreateBinary");
38 6 : ACL_REQUIRES_NOT_NULL_RET_NULL_INPUT_REPORT(data);
39 :
40 5 : rtDevBinary_t *binaryDesc = new(std::nothrow) rtDevBinary_t();
41 5 : ACL_CHECK_WITH_MESSAGE_AND_RETURN(binaryDesc != nullptr, nullptr, "Allocate memory for binaryDesc failed.");
42 :
43 5 : binaryDesc->magic = 0U;
44 5 : binaryDesc->version = 0U;
45 5 : binaryDesc->data = data;
46 5 : binaryDesc->length = static_cast<uint64_t>(dataLen);
47 :
48 5 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_ALLOCATOR_BINARY_DESC);
49 5 : return binaryDesc;
50 : }
51 :
52 6 : aclError aclrtDestroyBinaryImpl(aclrtBinary binary)
53 : {
54 6 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_ALLOCATOR_BINARY_DESC);
55 6 : ACL_LOG_INFO("start to execute aclrtDestroyBinary");
56 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binary);
57 :
58 5 : delete reinterpret_cast<rtDevBinary_t *>(binary);
59 :
60 5 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_ALLOCATOR_BINARY_DESC);
61 5 : return ACL_SUCCESS;
62 : }
63 :
64 4 : aclError aclrtBinaryLoadImpl(const aclrtBinary binary, aclrtBinHandle *binHandle)
65 : {
66 4 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_LOAD_UNLOAD_BINARY);
67 4 : ACL_LOG_INFO("start to execute aclrtBinaryLoad");
68 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binary);
69 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
70 2 : rtDevBinary_t *bin = reinterpret_cast<rtDevBinary_t *>(binary);
71 2 : const rtError_t rtErr = rtBinaryLoadWithoutTilingKey(bin->data, bin->length, binHandle);
72 2 : if (rtErr != RT_ERROR_NONE) {
73 1 : ACL_LOG_CALL_ERROR("rtBinaryLoad failed, runtime result = %d.", rtErr);
74 1 : return ACL_GET_ERRCODE_RTS(rtErr);
75 : }
76 :
77 1 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_LOAD_UNLOAD_BINARY);
78 1 : return ACL_SUCCESS;
79 : }
80 :
81 3 : aclError aclrtBinaryUnLoadImpl(aclrtBinHandle binHandle)
82 : {
83 3 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_LOAD_UNLOAD_BINARY);
84 3 : ACL_LOG_INFO("start to execute aclrtBinaryUnLoad");
85 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
86 :
87 2 : const rtError_t rtErr = rtBinaryUnLoad(binHandle);
88 2 : if (rtErr != RT_ERROR_NONE) {
89 1 : ACL_LOG_CALL_ERROR("rtBinaryUnLoad failed, runtime result = %d.", rtErr);
90 1 : return ACL_GET_ERRCODE_RTS(rtErr);
91 : }
92 :
93 1 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_LOAD_UNLOAD_BINARY);
94 1 : return ACL_SUCCESS;
95 : }
96 :
97 5 : aclError aclrtBinaryGetFunctionImpl(const aclrtBinHandle binHandle, const char *kernelName, aclrtFuncHandle *funcHandle)
98 : {
99 5 : ACL_LOG_INFO("start to execute aclrtBinaryGetFunction");
100 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
101 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(kernelName);
102 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
103 :
104 : // currently not support multi kernel, so tilingKey always use 0
105 2 : const rtError_t rtErr = rtsFuncGetByName(binHandle, kernelName, funcHandle);
106 2 : if (rtErr != RT_ERROR_NONE) {
107 1 : ACL_LOG_CALL_ERROR("rtBinaryGetFunction failed, runtime result = %d.", rtErr);
108 1 : return ACL_GET_ERRCODE_RTS(rtErr);
109 : }
110 :
111 1 : return ACL_SUCCESS;
112 : }
113 :
114 6 : aclError aclrtLaunchKernelImpl(aclrtFuncHandle funcHandle, uint32_t numBlocks, const void *argsData,
115 : size_t argsSize, aclrtStream stream)
116 : {
117 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchKernel);
118 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
119 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsData);
120 :
121 4 : rtArgsEx_t argsInfo = {};
122 4 : argsInfo.args = const_cast<void *>(argsData);
123 4 : argsInfo.argsSize = static_cast<uint32_t>(argsSize);
124 4 : argsInfo.isNoNeedH2DCopy = 1U;
125 :
126 4 : const rtError_t rtErr = rtLaunchKernelByFuncHandleV3(funcHandle, numBlocks, &argsInfo, stream, nullptr);
127 4 : if (rtErr != RT_ERROR_NONE) {
128 2 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
129 1 : ACL_LOG_WARN("rtLaunchKernelByFuncHandleV3 funHandle is invalid, runtime result = %d.", rtErr);
130 1 : return ACL_ERROR_RT_INVALID_HANDLE;
131 : } else {
132 1 : ACL_LOG_CALL_ERROR("rtLaunchKernelByFuncHandleV3 failed, runtime result = %d.", rtErr);
133 1 : return ACL_GET_ERRCODE_RTS(rtErr);
134 : }
135 : }
136 2 : return ACL_SUCCESS;
137 : }
138 :
139 3 : aclError aclrtBinaryLoadFromFileImpl(const char* binPath, aclrtBinaryLoadOptions *options, aclrtBinHandle *binHandle)
140 : {
141 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtBinaryLoadFromFile);
142 3 : ACL_LOG_INFO("start to execute aclrtBinaryLoadFromFile, binPath[%s]", binPath);
143 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binPath);
144 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
145 2 : const rtLoadBinaryConfig_t *rt_options = nullptr;
146 2 : if (options != nullptr) {
147 1 : rt_options = reinterpret_cast<rtLoadBinaryConfig_t *>(options);
148 : }
149 2 : const auto rtErr = rtsBinaryLoadFromFile(binPath, rt_options, binHandle);
150 2 : if (rtErr != RT_ERROR_NONE) {
151 1 : ACL_LOG_CALL_ERROR("Binary load from file Failed, runtime result = %d", rtErr);
152 1 : return ACL_GET_ERRCODE_RTS(rtErr);
153 : }
154 1 : return ACL_SUCCESS;
155 : }
156 :
157 3 : aclError aclrtBinaryGetDevAddressImpl(const aclrtBinHandle binHandle, void **binAddr, size_t *binSize)
158 : {
159 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtBinaryGetDevAddress);
160 3 : ACL_LOG_INFO("start to execute aclrtBinaryGetDevAddress");
161 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(binHandle);
162 2 : uint32_t tempBinSize = 0U;
163 :
164 2 : const auto rtErr = rtsBinaryGetDevAddress(binHandle, binAddr, &tempBinSize);
165 2 : if (rtErr != RT_ERROR_NONE) {
166 1 : ACL_LOG_INFO("get bin address failed, runtime result = %d", rtErr);
167 1 : return ACL_GET_ERRCODE_RTS(rtErr);
168 : }
169 1 : *binSize = static_cast<size_t>(tempBinSize);
170 1 : ACL_LOG_INFO("successfully execute aclrtBinaryGetDevAddress");
171 1 : return ACL_SUCCESS;
172 : }
173 :
174 3 : aclError aclrtBinaryGetFunctionByEntryImpl(aclrtBinHandle binHandle, uint64_t funcEntry, aclrtFuncHandle *funcHandle)
175 : {
176 3 : ACL_LOG_INFO("start to execute aclrtBinaryGetFunctionByEntry");
177 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
178 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
179 :
180 2 : const auto rtErr = rtsFuncGetByEntry(binHandle, funcEntry, funcHandle);
181 2 : if (rtErr != RT_ERROR_NONE) {
182 1 : ACL_LOG_CALL_ERROR("Binary get function by entry Failed, runtime result = %d", rtErr);
183 1 : return ACL_GET_ERRCODE_RTS(rtErr);
184 : }
185 1 : return ACL_SUCCESS;
186 : }
187 :
188 3 : aclError aclrtGetFunctionAddrImpl(aclrtFuncHandle funcHandle, void **aicAddr, void **aivAddr)
189 : {
190 3 : ACL_LOG_INFO("start to execute aclrtGetFunctionAddr");
191 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
192 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(aicAddr);
193 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(aivAddr);
194 :
195 2 : const auto rtErr = rtsFuncGetAddr(funcHandle, aicAddr, aivAddr);
196 2 : if (rtErr != RT_ERROR_NONE) {
197 1 : ACL_LOG_CALL_ERROR("Get function addr Failed, runtime result = %d", rtErr);
198 1 : return ACL_GET_ERRCODE_RTS(rtErr);
199 : }
200 1 : return ACL_SUCCESS;
201 : }
202 :
203 6 : aclError aclrtLaunchKernelWithConfigImpl(aclrtFuncHandle funcHandle, uint32_t numBlocks, aclrtStream stream,
204 : aclrtLaunchKernelCfg *cfg, aclrtArgsHandle argsHandle, void *reserve)
205 : {
206 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchKernelWithConfig);
207 6 : ACL_LOG_INFO("Start to execute aclrtLaunchKernelWithConfig");
208 6 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(funcHandle);
209 5 : ACL_REQUIRES_POSITIVE_WITH_INPUT_REPORT(numBlocks);
210 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(argsHandle);
211 3 : if (reserve != nullptr) {
212 0 : ACL_LOG_ERROR("[Check][reserve]param is reserved and only support currently nullptr.");
213 0 : return ACL_ERROR_INVALID_PARAM;
214 : }
215 :
216 3 : rtKernelLaunchCfg_t *rt_cfg = nullptr;
217 3 : if (cfg != nullptr ) {
218 1 : rt_cfg = reinterpret_cast<rtKernelLaunchCfg_t *>(cfg);
219 : }
220 3 : const auto rtErr = rtsLaunchKernelWithConfig(funcHandle, numBlocks, stream, rt_cfg, argsHandle, reserve);
221 3 : if (rtErr != RT_ERROR_NONE) {
222 2 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
223 1 : ACL_LOG_WARN("Launch kernel with config funHandle is invalid, runtime result = %d.", rtErr);
224 1 : return ACL_ERROR_RT_INVALID_HANDLE;
225 : } else {
226 1 : ACL_LOG_CALL_ERROR("Launch kernel with config failed, runtime result = %d.", rtErr);
227 1 : return ACL_GET_ERRCODE_RTS(rtErr);
228 : }
229 : }
230 1 : return ACL_SUCCESS;
231 : }
232 :
233 3 : aclError aclrtKernelArgsInitImpl(aclrtFuncHandle funcHandle, aclrtArgsHandle *argsHandle)
234 : {
235 3 : ACL_LOG_INFO("Start to execute aclrtKernelArgsInit");
236 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(funcHandle);
237 2 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(argsHandle);
238 :
239 2 : const auto rtErr = rtsKernelArgsInit(funcHandle, argsHandle);
240 2 : if (rtErr != RT_ERROR_NONE) {
241 1 : ACL_LOG_CALL_ERROR("Initialize kernel args Failed, runtime result = %d", rtErr);
242 1 : return ACL_GET_ERRCODE_RTS(rtErr);
243 : }
244 1 : return ACL_SUCCESS;
245 : }
246 :
247 6 : aclError aclrtKernelArgsInitByUserMemImpl(aclrtFuncHandle funcHandle, aclrtArgsHandle argsHandle, void *userHostMem,
248 : size_t actualArgsSize)
249 : {
250 6 : ACL_LOG_INFO("Start to execute aclrtKernelArgsInitByUserMem");
251 6 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(funcHandle);
252 5 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(argsHandle);
253 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(userHostMem);
254 3 : ACL_REQUIRES_POSITIVE_WITH_INPUT_REPORT(actualArgsSize);
255 :
256 2 : const auto rtErr = rtsKernelArgsInitByUserMem(funcHandle, argsHandle, userHostMem, actualArgsSize);
257 2 : if (rtErr != RT_ERROR_NONE) {
258 1 : ACL_LOG_CALL_ERROR("Initialize kernel args by user mem Failed, runtime result = %d", rtErr);
259 1 : return ACL_GET_ERRCODE_RTS(rtErr);
260 : }
261 1 : return ACL_SUCCESS;
262 : }
263 :
264 3 : aclError aclrtKernelArgsGetMemSizeImpl(aclrtFuncHandle funcHandle, size_t userArgsSize, size_t *actualArgsSize)
265 : {
266 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsGetMemSize);
267 3 : ACL_LOG_INFO("Start to execute aclrtKernelArgsGetMemSize");
268 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(funcHandle);
269 2 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(actualArgsSize);
270 :
271 2 : const auto rtErr = rtsKernelArgsGetMemSize(funcHandle, userArgsSize, actualArgsSize);
272 2 : if (rtErr != RT_ERROR_NONE) {
273 1 : ACL_LOG_CALL_ERROR("Get kernel args mem size Failed, runtime result = %d", rtErr);
274 1 : return ACL_GET_ERRCODE_RTS(rtErr);
275 : }
276 1 : return ACL_SUCCESS;
277 : }
278 :
279 3 : aclError aclrtKernelArgsGetHandleMemSizeImpl(aclrtFuncHandle funcHandle, size_t *memSize)
280 : {
281 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsGetHandleMemSize);
282 3 : ACL_LOG_INFO("Start to execute aclrtKernelArgsGetHandleMemSize");
283 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(funcHandle);
284 2 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(memSize);
285 :
286 2 : const auto rtErr = rtsKernelArgsGetHandleMemSize(funcHandle, memSize);
287 2 : if (rtErr != RT_ERROR_NONE) {
288 1 : ACL_LOG_CALL_ERROR("Get kernel args handle mem size Failed, runtime result = %d", rtErr);
289 1 : return ACL_GET_ERRCODE_RTS(rtErr);
290 : }
291 1 : return ACL_SUCCESS;
292 : }
293 :
294 5 : aclError aclrtKernelArgsAppendImpl(aclrtArgsHandle argsHandle, void *param, size_t paramSize,
295 : aclrtParamHandle *paramHandle)
296 : {
297 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsAppend);
298 5 : ACL_LOG_INFO("Start to execute aclrtKernelArgsAppend");
299 5 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(argsHandle);
300 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(param);
301 3 : ACL_REQUIRES_POSITIVE_WITH_INPUT_REPORT(paramSize);
302 2 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(paramHandle);
303 :
304 2 : const auto rtErr = rtsKernelArgsAppend(argsHandle, param, paramSize, paramHandle);
305 2 : if (rtErr != RT_ERROR_NONE) {
306 1 : ACL_LOG_CALL_ERROR("Append kernel args Failed, runtime result = %d", rtErr);
307 1 : return ACL_GET_ERRCODE_RTS(rtErr);
308 : }
309 1 : return ACL_SUCCESS;
310 : }
311 :
312 3 : aclError aclrtKernelArgsAppendPlaceHolderImpl(aclrtArgsHandle argsHandle, aclrtParamHandle *paramHandle)
313 : {
314 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsAppendPlaceHolder);
315 3 : ACL_LOG_INFO("Start to execute aclrtKernelArgsAppendPlaceHolder");
316 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(argsHandle);
317 2 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(paramHandle);
318 :
319 2 : const auto rtErr = rtsKernelArgsAppendPlaceHolder(argsHandle, paramHandle);
320 2 : if (rtErr != RT_ERROR_NONE) {
321 1 : ACL_LOG_CALL_ERROR("Append kernel args placeholder Failed, runtime result = %d", rtErr);
322 1 : return ACL_GET_ERRCODE_RTS(rtErr);
323 : }
324 1 : return ACL_SUCCESS;
325 : }
326 :
327 5 : aclError aclrtKernelArgsGetPlaceHolderBufferImpl(aclrtArgsHandle argsHandle, aclrtParamHandle paramHandle,
328 : size_t dataSize, void **bufferAddr)
329 : {
330 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsGetPlaceHolderBuffer);
331 5 : ACL_LOG_INFO("Start to execute aclrtKernelArgsGetPlaceHolderBuffer");
332 5 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(argsHandle);
333 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(paramHandle);
334 3 : ACL_REQUIRES_POSITIVE_WITH_INPUT_REPORT(dataSize);
335 2 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(bufferAddr);
336 :
337 2 : const auto rtErr = rtsKernelArgsGetPlaceHolderBuffer(argsHandle, paramHandle, dataSize, bufferAddr);
338 2 : if (rtErr != RT_ERROR_NONE) {
339 1 : ACL_LOG_CALL_ERROR("Get kernel args placeholder buffer Failed, runtime result = %d", rtErr);
340 1 : return ACL_GET_ERRCODE_RTS(rtErr);
341 : }
342 1 : return ACL_SUCCESS;
343 : }
344 :
345 6 : aclError aclrtKernelArgsParaUpdateImpl(aclrtArgsHandle argsHandle, aclrtParamHandle paramHandle, void *param,
346 : size_t paramSize)
347 : {
348 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsParaUpdate);
349 6 : ACL_LOG_INFO("Start to execute aclrtKernelArgsParaUpdate");
350 6 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(argsHandle);
351 5 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(paramHandle);
352 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(param);
353 3 : ACL_REQUIRES_POSITIVE_WITH_INPUT_REPORT(paramSize);
354 :
355 2 : const auto rtErr = rtsKernelArgsParaUpdate(argsHandle, paramHandle, param, paramSize);
356 2 : if (rtErr != RT_ERROR_NONE) {
357 1 : ACL_LOG_CALL_ERROR("Update kernel args placeholder Failed, runtime result = %d", rtErr);
358 1 : return ACL_GET_ERRCODE_RTS(rtErr);
359 : }
360 1 : return ACL_SUCCESS;
361 : }
362 :
363 2 : aclError aclrtKernelArgsFinalizeImpl(aclrtArgsHandle argsHandle)
364 : {
365 2 : ACL_LOG_INFO("Start to execute aclrtKernelArgsFinalize");
366 2 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(argsHandle);
367 :
368 2 : const auto rtErr = rtsKernelArgsFinalize(argsHandle);
369 2 : if (rtErr != RT_ERROR_NONE) {
370 1 : ACL_LOG_CALL_ERROR("Finalize kernel args Failed, runtime result = %d", rtErr);
371 1 : return ACL_GET_ERRCODE_RTS(rtErr);
372 : }
373 1 : return ACL_SUCCESS;
374 : }
375 :
376 2 : aclError aclrtGetThreadLastTaskIdImpl(uint32_t *taskId)
377 : {
378 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetThreadLastTaskId);
379 2 : ACL_LOG_DEBUG("start to execute aclrtGetThreadLastTaskId");
380 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(taskId);
381 2 : const rtError_t rtErr = rtsGetThreadLastTaskId(taskId);
382 2 : if (rtErr != RT_ERROR_NONE) {
383 1 : ACL_LOG_CALL_ERROR("call rtsGetThreadLastTaskId failed, runtime result = %d", rtErr);
384 1 : return ACL_GET_ERRCODE_RTS(rtErr);
385 : }
386 1 : return ACL_SUCCESS;
387 : }
388 :
389 4 : aclError aclrtGetFunctionNameImpl(aclrtFuncHandle funcHandle, uint32_t maxLen, char *name)
390 : {
391 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetFunctionName);
392 4 : ACL_LOG_DEBUG("start to execute aclrtGetFunctionName, maxLen is [%u]", maxLen);
393 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(name);
394 2 : const rtError_t rtErr = rtsFuncGetName(static_cast<rtFuncHandle>(funcHandle), maxLen, name);
395 2 : if (rtErr != RT_ERROR_NONE) {
396 1 : ACL_LOG_CALL_ERROR("call rtsFuncGetName failed, runtime result = %d", rtErr);
397 1 : return ACL_GET_ERRCODE_RTS(rtErr);
398 : }
399 1 : return ACL_SUCCESS;
400 : }
401 :
402 4 : aclError aclrtBinaryLoadFromDataImpl(const void *data, size_t length,
403 : const aclrtBinaryLoadOptions *options, aclrtBinHandle *binHandle)
404 : {
405 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtBinaryLoadFromData);
406 4 : ACL_LOG_DEBUG("start to execute aclrtBinaryLoadFromData, length is [%zu]", length);
407 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(data);
408 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
409 2 : const rtError_t rtErr = rtsBinaryLoadFromData(data, length,
410 : reinterpret_cast<const rtLoadBinaryConfig_t*>(options), static_cast<rtBinHandle*>(binHandle));
411 2 : if (rtErr != RT_ERROR_NONE) {
412 1 : ACL_LOG_CALL_ERROR("call rtsBinaryLoadFromData failed, runtime result = %d", rtErr);
413 1 : return ACL_GET_ERRCODE_RTS(rtErr);
414 : }
415 1 : return ACL_SUCCESS;
416 : }
417 :
418 6 : aclError aclrtRegisterCpuFuncImpl(const aclrtBinHandle handle, const char *funcName,
419 : const char *kernelName, aclrtFuncHandle *funcHandle)
420 : {
421 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtRegisterCpuFunc);
422 6 : ACL_LOG_DEBUG("start to execute aclrtRegisterCpuFunc");
423 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
424 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcName);
425 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(kernelName);
426 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
427 2 : const rtError_t rtErr = rtsRegisterCpuFunc(static_cast<rtBinHandle>(handle), funcName, kernelName,
428 : static_cast<rtFuncHandle*>(funcHandle));
429 2 : if (rtErr != RT_ERROR_NONE) {
430 1 : ACL_LOG_CALL_ERROR("call rtsRegisterCpuFunc failed, runtime result = %d", rtErr);
431 1 : return ACL_GET_ERRCODE_RTS(rtErr);
432 : }
433 1 : return ACL_SUCCESS;
434 : }
435 :
436 5 : aclError aclrtCmoWaitBarrierImpl(aclrtBarrierTaskInfo *taskInfo, aclrtStream stream, uint32_t flag)
437 : {
438 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtCmoWaitBarrier);
439 5 : ACL_LOG_DEBUG("start to execute aclrtCmoWaitBarrier, flag is [%u]", flag);
440 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(taskInfo);
441 4 : if ((taskInfo->barrierNum == 0U) || (taskInfo->barrierNum > ACL_RT_CMO_MAX_BARRIER_NUM)) {
442 2 : ACL_LOG_ERROR("[Check][taskInfo]param taskInfo is invalid, taskInfo->barrierNum must be in range (0, 6]");
443 2 : return ACL_ERROR_INVALID_PARAM;
444 : }
445 2 : rtBarrierTaskInfo_t rtTaskInfo;
446 2 : rtTaskInfo.logicIdNum = taskInfo->barrierNum;
447 4 : for (size_t i = 0U; i < taskInfo->barrierNum; i++) {
448 2 : rtTaskInfo.cmoInfo[i].cmoType = static_cast<uint16_t>(taskInfo->cmoInfo[i].cmoType) +
449 : (static_cast<uint16_t>(RT_CMO_PREFETCH) - static_cast<uint16_t>(ACL_RT_CMO_TYPE_PREFETCH));
450 2 : rtTaskInfo.cmoInfo[i].logicId = taskInfo->cmoInfo[i].barrierId;
451 : }
452 2 : const rtError_t rtErr = rtsLaunchBarrierTask(&rtTaskInfo, static_cast<rtStream_t>(stream), flag);
453 2 : if (rtErr != RT_ERROR_NONE) {
454 1 : ACL_LOG_CALL_ERROR("call rtsLaunchBarrierTask failed, runtime result = %d", rtErr);
455 1 : return ACL_GET_ERRCODE_RTS(rtErr);
456 : }
457 1 : return ACL_SUCCESS;
458 : }
459 :
460 6 : aclError aclrtLaunchKernelV2Impl(aclrtFuncHandle funcHandle, uint32_t numBlocks, const void *argsData,
461 : size_t argsSize, aclrtLaunchKernelCfg *cfg, aclrtStream stream)
462 : {
463 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchKernelV2);
464 6 : ACL_LOG_INFO("Start to execute aclrtLaunchKernelV2");
465 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
466 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsData);
467 :
468 4 : rtKernelLaunchCfg_t *rt_cfg = nullptr;
469 4 : if (cfg != nullptr ) {
470 1 : rt_cfg = reinterpret_cast<rtKernelLaunchCfg_t *>(cfg);
471 : }
472 :
473 4 : const rtError_t rtErr = rtsLaunchKernelWithDevArgs(funcHandle, numBlocks, stream, rt_cfg,
474 : argsData, static_cast<uint32_t>(argsSize), nullptr);
475 4 : if (rtErr != RT_ERROR_NONE) {
476 2 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
477 1 : ACL_LOG_WARN("rtsLaunchKernelWithDevArgs funHandle is invalid, runtime result = %d.", rtErr);
478 1 : return ACL_ERROR_RT_INVALID_HANDLE;
479 : } else {
480 1 : ACL_LOG_CALL_ERROR("rtsLaunchKernelWithDevArgs failed, runtime result = %d.", rtErr);
481 1 : return ACL_GET_ERRCODE_RTS(rtErr);
482 : }
483 : }
484 :
485 2 : return ACL_SUCCESS;
486 : }
487 :
488 6 : aclError aclrtLaunchKernelWithHostArgsImpl(aclrtFuncHandle funcHandle, uint32_t numBlocks, aclrtStream stream,
489 : aclrtLaunchKernelCfg *cfg, void *hostArgs, size_t argsSize,
490 : aclrtPlaceHolderInfo *placeHolderArray, size_t placeHolderNum)
491 : {
492 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchKernelWithHostArgs);
493 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
494 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(hostArgs);
495 :
496 4 : rtKernelLaunchCfg_t *rt_cfg = nullptr;
497 4 : rtPlaceHolderInfo_t *rt_placeHolderArray = nullptr;
498 4 : if (cfg != nullptr ) {
499 1 : rt_cfg = reinterpret_cast<rtKernelLaunchCfg_t *>(cfg);
500 : }
501 :
502 4 : if (placeHolderArray != nullptr ) {
503 1 : rt_placeHolderArray = reinterpret_cast<rtPlaceHolderInfo_t *>(placeHolderArray);
504 : }
505 :
506 4 : const rtError_t rtErr = rtsLaunchKernelWithHostArgs(funcHandle, numBlocks, stream, rt_cfg,
507 : hostArgs, static_cast<uint32_t>(argsSize), rt_placeHolderArray, placeHolderNum);
508 4 : if (rtErr != RT_ERROR_NONE) {
509 2 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
510 1 : ACL_LOG_WARN("rtsLaunchKernelWithHostArgs funHandle is invalid, runtime result = %d.", rtErr);
511 1 : return ACL_ERROR_RT_INVALID_HANDLE;
512 : } else {
513 1 : ACL_LOG_CALL_ERROR("rtsLaunchKernelWithHostArgs failed, runtime result = %d.", rtErr);
514 1 : return ACL_GET_ERRCODE_RTS(rtErr);
515 : }
516 : }
517 :
518 2 : return ACL_SUCCESS;
519 : }
520 :
521 2 : aclError aclrtGetFloatOverflowStatusImpl(void *outputAddr, uint64_t outputSize, aclrtStream stream)
522 : {
523 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetFloatOverflowStatus);
524 2 : ACL_LOG_INFO("start to execute aclrtGetFloatOverflowStatus, outputSize = %lu", outputSize);
525 2 : const rtError_t rtErr = rtsGetFloatOverflowStatus(outputAddr, outputSize, static_cast<rtStream_t>(stream));
526 2 : if (rtErr != RT_ERROR_NONE) {
527 1 : ACL_LOG_CALL_ERROR("rtsGetFloatOverflowStatus failed, runtime result = %d.", static_cast<int32_t>(rtErr));
528 1 : return ACL_GET_ERRCODE_RTS(rtErr);
529 : }
530 1 : ACL_LOG_INFO("successfully execute aclrtGetFloatOverflowStatus");
531 1 : return ACL_SUCCESS;
532 : }
533 :
534 2 : aclError aclrtResetFloatOverflowStatusImpl(aclrtStream stream)
535 : {
536 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtResetFloatOverflowStatus);
537 2 : ACL_LOG_INFO("start to execute aclrtResetFloatOverflowStatus");
538 2 : const rtError_t rtErr = rtsResetFloatOverflowStatus(static_cast<rtStream_t>(stream));
539 2 : if (rtErr != RT_ERROR_NONE) {
540 1 : ACL_LOG_CALL_ERROR("rtsResetFloatOverflowStatus failed, runtime result = %d.", static_cast<int32_t>(rtErr));
541 1 : return ACL_GET_ERRCODE_RTS(rtErr);
542 : }
543 1 : ACL_LOG_INFO("successfully execute aclrtResetFloatOverflowStatus");
544 1 : return ACL_SUCCESS;
545 : }
546 :
547 2 : aclError aclrtNpuGetFloatOverFlowStatusImpl(void *outputAddr, uint64_t outputSize, uint32_t checkMode, aclrtStream stream)
548 : {
549 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtNpuGetFloatOverFlowStatus);
550 2 : ACL_LOG_INFO("start to execute aclrtNpuGetFloatOverFlowStatus, outputSize = %lu", outputSize);
551 2 : const rtError_t rtErr = rtsNpuGetFloatOverFlowStatus(outputAddr, outputSize, checkMode, static_cast<rtStream_t>(stream));
552 2 : if (rtErr != RT_ERROR_NONE) {
553 1 : ACL_LOG_CALL_ERROR("rtsNpuGetFloatOverFlowStatus failed, runtime result = %d.", static_cast<int32_t>(rtErr));
554 1 : return ACL_GET_ERRCODE_RTS(rtErr);
555 : }
556 1 : ACL_LOG_INFO("successfully execute aclrtNpuGetFloatOverFlowStatus");
557 1 : return ACL_SUCCESS;
558 : }
559 :
560 2 : aclError aclrtNpuClearFloatOverFlowStatusImpl(uint32_t checkMode, aclrtStream stream)
561 : {
562 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtNpuClearFloatOverFlowStatus);
563 2 : ACL_LOG_INFO("start to execute aclrtNpuClearFloatOverFlowStatus");
564 2 : const rtError_t rtErr = rtsNpuClearFloatOverFlowStatus(checkMode, static_cast<rtStream_t>(stream));
565 2 : if (rtErr != RT_ERROR_NONE) {
566 1 : ACL_LOG_CALL_ERROR("rtsNpuClearFloatOverFlowStatus failed, runtime result = %d.", static_cast<int32_t>(rtErr));
567 1 : return ACL_GET_ERRCODE_RTS(rtErr);
568 : }
569 1 : ACL_LOG_INFO("successfully execute aclrtNpuClearFloatOverFlowStatus");
570 1 : return ACL_SUCCESS;
571 : }
572 :
573 2 : aclError aclrtGetHardwareSyncAddrImpl(void **addr)
574 : {
575 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetHardwareSyncAddr);
576 2 : const rtError_t rtErr = rtsGetHardwareSyncAddr(addr);
577 2 : if (rtErr != RT_ERROR_NONE) {
578 1 : ACL_LOG_CALL_ERROR("call rtsGetHardwareSyncAddr failed, runtime result = %d.", static_cast<int32_t>(rtErr));
579 1 : return ACL_GET_ERRCODE_RTS(rtErr);
580 : }
581 1 : return ACL_SUCCESS;
582 : }
583 :
584 4 : aclError aclrtRandomNumAsyncImpl(const aclrtRandomNumTaskInfo *taskInfo, const aclrtStream stream, void *reserve)
585 : {
586 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtRandomNumAsync);
587 4 : ACL_LOG_INFO("start to execute aclrtRandomNumAsync");
588 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(taskInfo);
589 3 : aclDataType type = taskInfo->dataType;
590 3 : if (kMapDataType.count(type) == 0) {
591 1 : ACL_LOG_ERROR("[Check][param]param dataType [%d] is invalid.", static_cast<int32_t>(type));
592 1 : return ACL_ERROR_INVALID_PARAM;
593 : }
594 2 : rtRandomNumTaskInfo_t *rtTaskInfo = const_cast<rtRandomNumTaskInfo_t *>(reinterpret_cast<const rtRandomNumTaskInfo_t *>(taskInfo));
595 2 : rtTaskInfo->dataType = kMapDataType.at(type);
596 2 : const rtError_t rtErr = rtsLaunchRandomNumTask(
597 : rtTaskInfo,
598 : static_cast<rtStream_t>(stream), reserve);
599 2 : if (rtErr != RT_ERROR_NONE) {
600 1 : ACL_LOG_CALL_ERROR(
601 : "call rtsLaunchRandomNumTask failed, runtime result = %d.",
602 : static_cast<int32_t>(rtErr));
603 1 : return ACL_GET_ERRCODE_RTS(rtErr);
604 : }
605 1 : ACL_LOG_INFO("successfully execute aclrtRandomNumAsync");
606 1 : return ACL_SUCCESS;
607 : }
608 :
609 7 : aclError aclrtTaskUpdateAsyncImpl(aclrtStream taskStream, uint32_t taskId, aclrtTaskUpdateInfo *info, aclrtStream execStream)
610 : {
611 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtTaskUpdateAsync);
612 7 : ACL_LOG_INFO("start to execute aclrtTaskUpdateAsync");
613 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(info);
614 : const rtError_t rtErr =
615 6 : rtsLaunchUpdateTask(static_cast<rtStream_t>(taskStream), taskId,
616 : static_cast<rtStream_t>(execStream),
617 : reinterpret_cast<rtTaskUpdateCfg_t *>(info));
618 6 : if (rtErr != RT_ERROR_NONE) {
619 1 : ACL_LOG_CALL_ERROR(
620 : "call rtsLaunchUpdateTask failed, runtime result = %d.",
621 : static_cast<int32_t>(rtErr));
622 1 : return ACL_GET_ERRCODE_RTS(rtErr);
623 : }
624 5 : ACL_LOG_INFO("successfully execute aclrtTaskUpdateAsync");
625 5 : return ACL_SUCCESS;
626 : }
627 :
628 5 : aclError aclrtCacheLastTaskOpInfoImpl(const void * const infoPtr, const size_t infoSize)
629 : {
630 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtCacheLastTaskOpInfo);
631 5 : ACL_LOG_INFO("start to execute aclrtCacheLastTaskOpInfo");
632 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(infoPtr);
633 4 : ACL_REQUIRES_POSITIVE_WITH_INPUT_REPORT(infoSize);
634 :
635 3 : const rtError_t rtErr = rtCacheLastTaskOpInfo(infoPtr, infoSize);
636 3 : if (rtErr != RT_ERROR_NONE) {
637 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
638 1 : ACL_LOG_WARN("rtCacheLastTaskOpInfo unsupport, runtime result = %d", static_cast<int32_t>(rtErr));
639 : } else {
640 1 : ACL_LOG_CALL_ERROR("call rtCacheLastTaskOpInfo failed, runtime result = %d.", static_cast<int32_t>(rtErr));
641 : }
642 2 : return ACL_GET_ERRCODE_RTS(rtErr);
643 : }
644 1 : ACL_LOG_INFO("successfully execute aclrtCacheLastTaskOpInfo");
645 1 : return ACL_SUCCESS;
646 : }
647 :
648 3 : aclError aclrtGetFunctionAttributeImpl(aclrtFuncHandle funcHandle, aclrtFuncAttribute attrType, int64_t *attrValue)
649 : {
650 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetFunctionAttribute);
651 3 : ACL_LOG_INFO("start to execute aclrtGetFunctionAttribute");
652 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
653 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(attrValue);
654 :
655 1 : const rtError_t rtErr = rtFunctionGetAttribute(funcHandle, static_cast<rtFuncAttribute>(attrType), attrValue);
656 1 : if (rtErr != RT_ERROR_NONE) {
657 1 : ACL_LOG_CALL_ERROR("call rtFunctionGetAttribute failed, runtime result = %d.", static_cast<int32_t>(rtErr));
658 1 : return ACL_GET_ERRCODE_RTS(rtErr);
659 : }
660 :
661 0 : ACL_LOG_INFO("successfully execute aclrtGetFunctionAttribute");
662 0 : return ACL_SUCCESS;
663 : }
|
