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/inner_kernel.h"
16 : #include "runtime/rt_stars_define.h"
17 : #include "runtime/rts/rts_stars.h"
18 : #include "runtime/rts/rts_model.h"
19 : #include "runtime/rt_inner_task.h"
20 : #include "common/log_inner.h"
21 : #include "common/error_codes_inner.h"
22 : #include "common/prof_reporter.h"
23 : #include "common/resource_statistics.h"
24 : #include "utils/data_type_utils.h"
25 : namespace {
26 : static const std::map<aclDataType, rtRandomNumDataType> kMapDataType = {
27 : {ACL_INT32, RT_RANDOM_NUM_DATATYPE_INT32}, {ACL_INT64, RT_RANDOM_NUM_DATATYPE_INT64},
28 : {ACL_UINT32, RT_RANDOM_NUM_DATATYPE_UINT32}, {ACL_UINT64, RT_RANDOM_NUM_DATATYPE_UINT64},
29 : {ACL_BF16, RT_RANDOM_NUM_DATATYPE_BF16}, {ACL_FLOAT16, RT_RANDOM_NUM_DATATYPE_FP16},
30 : {ACL_FLOAT, RT_RANDOM_NUM_DATATYPE_FP32},
31 : };
32 :
33 : }
34 :
35 : #ifdef __cplusplus
36 : extern "C" {
37 : #endif
38 :
39 6 : aclrtBinary aclrtCreateBinaryImpl(const void* data, size_t dataLen)
40 : {
41 6 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_ALLOCATOR_BINARY_DESC);
42 6 : ACL_LOG_INFO("start to execute aclrtCreateBinary");
43 10 : ACL_REQUIRES_NOT_NULL_RET_NULL_INPUT_REPORT(data);
44 :
45 5 : rtDevBinary_t* binaryDesc = new (std::nothrow) rtDevBinary_t();
46 5 : ACL_CHECK_MALLOC_RESULT_REPORT_RET(binaryDesc, sizeof(rtDevBinary_t), "new", nullptr);
47 :
48 5 : binaryDesc->magic = 0U;
49 5 : binaryDesc->version = 0U;
50 5 : binaryDesc->data = data;
51 5 : binaryDesc->length = static_cast<uint64_t>(dataLen);
52 :
53 5 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_ALLOCATOR_BINARY_DESC);
54 5 : return binaryDesc;
55 : }
56 :
57 6 : aclError aclrtDestroyBinaryImpl(aclrtBinary binary)
58 : {
59 6 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_ALLOCATOR_BINARY_DESC);
60 6 : ACL_LOG_INFO("start to execute aclrtDestroyBinary");
61 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binary);
62 :
63 5 : delete reinterpret_cast<rtDevBinary_t*>(binary);
64 :
65 5 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_ALLOCATOR_BINARY_DESC);
66 5 : return ACL_SUCCESS;
67 : }
68 :
69 4 : aclError aclrtBinaryLoadImpl(const aclrtBinary binary, aclrtBinHandle* binHandle)
70 : {
71 4 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_LOAD_UNLOAD_BINARY);
72 4 : ACL_LOG_INFO("start to execute aclrtBinaryLoad");
73 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binary);
74 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
75 2 : rtDevBinary_t* bin = reinterpret_cast<rtDevBinary_t*>(binary);
76 2 : ACL_REQUIRES_RTS_OK(rtBinaryLoadWithoutTilingKey(bin->data, bin->length, binHandle));
77 :
78 1 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_LOAD_UNLOAD_BINARY);
79 1 : return ACL_SUCCESS;
80 : }
81 :
82 3 : aclError aclrtBinaryUnLoadImpl(aclrtBinHandle binHandle)
83 : {
84 3 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_LOAD_UNLOAD_BINARY);
85 3 : ACL_LOG_INFO("start to execute aclrtBinaryUnLoad");
86 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
87 :
88 2 : ACL_REQUIRES_RTS_OK(rtBinaryUnLoad(binHandle));
89 :
90 1 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_LOAD_UNLOAD_BINARY);
91 1 : return ACL_SUCCESS;
92 : }
93 :
94 5 : aclError aclrtBinaryGetFunctionImpl(const aclrtBinHandle binHandle, const char* kernelName, aclrtFuncHandle* funcHandle)
95 : {
96 5 : ACL_LOG_INFO("start to execute aclrtBinaryGetFunction");
97 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
98 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(kernelName);
99 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
100 :
101 : // currently not support multi kernel, so tilingKey always use 0
102 2 : ACL_REQUIRES_RTS_OK(rtsFuncGetByName(binHandle, kernelName, funcHandle));
103 :
104 1 : return ACL_SUCCESS;
105 : }
106 :
107 3 : aclError aclmdlRITaskDisableImpl(aclmdlRITask task)
108 : {
109 3 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRITaskDisable);
110 3 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtModelTaskDisable(static_cast<rtTask_t>(task)), rtModelTaskDisable);
111 1 : return ACL_SUCCESS;
112 3 : }
113 :
114 6 : aclError aclrtLaunchKernelImpl(
115 : aclrtFuncHandle funcHandle, uint32_t numBlocks, const void* argsData, size_t argsSize, aclrtStream stream)
116 : {
117 6 : 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 : return ACL_GET_ERRCODE_RTS(rtErr);
133 : }
134 : }
135 2 : return ACL_SUCCESS;
136 6 : }
137 :
138 3 : aclError aclrtBinaryLoadFromFileImpl(const char* binPath, aclrtBinaryLoadOptions* options, aclrtBinHandle* binHandle)
139 : {
140 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtBinaryLoadFromFile);
141 3 : ACL_LOG_INFO("start to execute aclrtBinaryLoadFromFile, binPath[%s]", binPath);
142 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binPath);
143 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
144 2 : const rtLoadBinaryConfig_t* rt_options = nullptr;
145 2 : if (options != nullptr) {
146 1 : rt_options = reinterpret_cast<rtLoadBinaryConfig_t*>(options);
147 : }
148 2 : ACL_REQUIRES_RTS_OK(rtsBinaryLoadFromFile(binPath, rt_options, binHandle));
149 1 : return ACL_SUCCESS;
150 3 : }
151 :
152 3 : aclError aclrtBinaryGetDevAddressImpl(const aclrtBinHandle binHandle, void** binAddr, size_t* binSize)
153 : {
154 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtBinaryGetDevAddress);
155 3 : ACL_LOG_INFO("start to execute aclrtBinaryGetDevAddress");
156 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
157 2 : uint32_t tempBinSize = 0U;
158 :
159 2 : const auto rtErr = rtsBinaryGetDevAddress(binHandle, binAddr, &tempBinSize);
160 2 : if (rtErr != RT_ERROR_NONE) {
161 1 : ACL_LOG_INFO("get bin address failed, runtime result = %d", rtErr);
162 1 : return ACL_GET_ERRCODE_RTS(rtErr);
163 : }
164 1 : *binSize = static_cast<size_t>(tempBinSize);
165 1 : ACL_LOG_INFO("successfully execute aclrtBinaryGetDevAddress");
166 1 : return ACL_SUCCESS;
167 3 : }
168 :
169 3 : aclError aclrtBinaryGetFunctionByEntryImpl(aclrtBinHandle binHandle, uint64_t funcEntry, aclrtFuncHandle* funcHandle)
170 : {
171 3 : ACL_LOG_INFO("start to execute aclrtBinaryGetFunctionByEntry");
172 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
173 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
174 :
175 2 : ACL_REQUIRES_RTS_OK(rtsFuncGetByEntry(binHandle, funcEntry, funcHandle));
176 1 : return ACL_SUCCESS;
177 : }
178 :
179 7 : aclError aclrtBinaryGetGlobalImpl(aclrtBinHandle binHandle, const char* name, void** dptr, size_t* size)
180 : {
181 7 : ACL_LOG_INFO("start to execute aclrtBinaryGetGlobal");
182 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
183 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(name);
184 5 : if ((dptr == nullptr) && (size == nullptr)) {
185 1 : ACL_LOG_ERROR("[Check][dptr,size]dptr and size cannot both be null.");
186 4 : acl::AclErrorLogManager::ReportInputError(
187 : acl::INVALID_NULL_POINTER_AT_SAME_TIME_MSG, {"func", "param"}, {"aclrtBinaryGetGlobal", "dptr and size"});
188 1 : return ACL_ERROR_INVALID_PARAM;
189 : }
190 :
191 4 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtBinaryGetGlobal(binHandle, name, dptr, size), rtBinaryGetGlobal);
192 1 : ACL_LOG_INFO("execute aclrtBinaryGetGlobal success, name=%s", name);
193 1 : return ACL_SUCCESS;
194 : }
195 :
196 4 : aclError aclrtGetFuncBySymbolImpl(const void* symbol, aclrtFuncHandle* funcHandle)
197 : {
198 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetFuncBySymbol);
199 4 : ACL_LOG_INFO("start to execute aclrtGetFuncBySymbol");
200 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(symbol);
201 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
202 :
203 2 : ACL_REQUIRES_RTS_OK(rtGetFuncBySymbol(symbol, funcHandle));
204 1 : return ACL_SUCCESS;
205 4 : }
206 :
207 3 : aclError aclrtGetFunctionAddrImpl(aclrtFuncHandle funcHandle, void** aicAddr, void** aivAddr)
208 : {
209 3 : ACL_LOG_INFO("start to execute aclrtGetFunctionAddr");
210 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
211 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(aicAddr);
212 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(aivAddr);
213 :
214 2 : ACL_REQUIRES_RTS_OK(rtsFuncGetAddr(funcHandle, aicAddr, aivAddr));
215 1 : return ACL_SUCCESS;
216 : }
217 :
218 2 : aclError aclrtGetFunctionSizeImpl(aclrtFuncHandle funcHandle, size_t* aicSize, size_t* aivSize)
219 : {
220 2 : ACL_REQUIRES_RTS_OK(rtFuncGetSize(funcHandle, aicSize, aivSize));
221 1 : return ACL_SUCCESS;
222 : }
223 :
224 6 : aclError aclrtLaunchKernelWithConfigImpl(
225 : aclrtFuncHandle funcHandle, uint32_t numBlocks, aclrtStream stream, aclrtLaunchKernelCfg* cfg,
226 : aclrtArgsHandle argsHandle, void* reserve)
227 : {
228 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchKernelWithConfig);
229 6 : ACL_LOG_INFO("Start to execute aclrtLaunchKernelWithConfig");
230 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
231 8 : ACL_REQUIRES_POSITIVE_REPORT(numBlocks);
232 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsHandle);
233 3 : ACL_CHECK_INVALID_PARAM_NO_VALUE(
234 : reserve == nullptr, "reserve", "reserve is a reserved parameter and must be nullptr");
235 :
236 3 : rtKernelLaunchCfg_t* rt_cfg = nullptr;
237 3 : if (cfg != nullptr) {
238 1 : rt_cfg = reinterpret_cast<rtKernelLaunchCfg_t*>(cfg);
239 : }
240 3 : const auto rtErr = rtsLaunchKernelWithConfig(funcHandle, numBlocks, stream, rt_cfg, argsHandle, reserve);
241 3 : if (rtErr != RT_ERROR_NONE) {
242 2 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
243 1 : ACL_LOG_WARN("Launch kernel with config funHandle is invalid, runtime result = %d.", rtErr);
244 1 : return ACL_ERROR_RT_INVALID_HANDLE;
245 : } else {
246 1 : return ACL_GET_ERRCODE_RTS(rtErr);
247 : }
248 : }
249 1 : return ACL_SUCCESS;
250 6 : }
251 :
252 3 : aclError aclmdlRITaskGetParamsImpl(aclmdlRITask task, aclmdlRITaskParams* params)
253 : {
254 3 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRITaskGetParams);
255 3 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(
256 : rtModelTaskGetParams(static_cast<rtTask_t>(task), reinterpret_cast<rtTaskParams*>(params)),
257 : rtModelTaskGetParams);
258 1 : return ACL_SUCCESS;
259 3 : }
260 :
261 3 : aclError aclmdlRITaskSetParamsImpl(aclmdlRITask task, aclmdlRITaskParams* params)
262 : {
263 3 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRITaskSetParams);
264 3 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(
265 : rtModelTaskSetParams(static_cast<rtTask_t>(task), reinterpret_cast<rtTaskParams*>(params)),
266 : rtModelTaskSetParams);
267 1 : return ACL_SUCCESS;
268 3 : }
269 :
270 2 : aclError aclmdlRIKernelTaskGetAttributeImpl(
271 : aclmdlRITask task, aclrtLaunchKernelAttrId attrId, aclrtLaunchKernelAttrValue* attrValue)
272 : {
273 2 : ACL_PROFILING_REG(acl::AclProfType::aclmdlRIKernelTaskGetAttribute);
274 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(task);
275 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(attrValue);
276 2 : ACL_REQUIRES_RTS_OK(rtModelKernelTaskGetAttribute(
277 : static_cast<rtTask_t>(task), static_cast<rtLaunchKernelAttrId>(attrId),
278 : reinterpret_cast<rtLaunchKernelAttrVal_t*>(attrValue)));
279 1 : return ACL_SUCCESS;
280 2 : }
281 :
282 3 : aclError aclrtKernelArgsInitImpl(aclrtFuncHandle funcHandle, aclrtArgsHandle* argsHandle)
283 : {
284 3 : ACL_LOG_INFO("Start to execute aclrtKernelArgsInit");
285 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
286 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsHandle);
287 :
288 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsInit(funcHandle, argsHandle));
289 1 : return ACL_SUCCESS;
290 : }
291 :
292 6 : aclError aclrtKernelArgsInitByUserMemImpl(
293 : aclrtFuncHandle funcHandle, aclrtArgsHandle argsHandle, void* userHostMem, size_t actualArgsSize)
294 : {
295 6 : ACL_LOG_INFO("Start to execute aclrtKernelArgsInitByUserMem");
296 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
297 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsHandle);
298 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(userHostMem);
299 6 : ACL_REQUIRES_POSITIVE_REPORT(actualArgsSize);
300 :
301 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsInitByUserMem(funcHandle, argsHandle, userHostMem, actualArgsSize));
302 1 : return ACL_SUCCESS;
303 : }
304 :
305 3 : aclError aclrtKernelArgsGetMemSizeImpl(aclrtFuncHandle funcHandle, size_t userArgsSize, size_t* actualArgsSize)
306 : {
307 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsGetMemSize);
308 3 : ACL_LOG_INFO("Start to execute aclrtKernelArgsGetMemSize");
309 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
310 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(actualArgsSize);
311 :
312 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsGetMemSize(funcHandle, userArgsSize, actualArgsSize));
313 1 : return ACL_SUCCESS;
314 3 : }
315 :
316 3 : aclError aclrtKernelArgsGetHandleMemSizeImpl(aclrtFuncHandle funcHandle, size_t* memSize)
317 : {
318 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsGetHandleMemSize);
319 3 : ACL_LOG_INFO("Start to execute aclrtKernelArgsGetHandleMemSize");
320 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
321 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(memSize);
322 :
323 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsGetHandleMemSize(funcHandle, memSize));
324 1 : return ACL_SUCCESS;
325 3 : }
326 :
327 5 : aclError aclrtKernelArgsAppendImpl(
328 : aclrtArgsHandle argsHandle, void* param, size_t paramSize, aclrtParamHandle* paramHandle)
329 : {
330 5 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsAppend);
331 5 : ACL_LOG_INFO("Start to execute aclrtKernelArgsAppend");
332 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsHandle);
333 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(param);
334 6 : ACL_REQUIRES_POSITIVE_REPORT(paramSize);
335 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(paramHandle);
336 :
337 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsAppend(argsHandle, param, paramSize, paramHandle));
338 1 : return ACL_SUCCESS;
339 5 : }
340 :
341 3 : aclError aclrtKernelArgsAppendPlaceHolderImpl(aclrtArgsHandle argsHandle, aclrtParamHandle* paramHandle)
342 : {
343 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsAppendPlaceHolder);
344 3 : ACL_LOG_INFO("Start to execute aclrtKernelArgsAppendPlaceHolder");
345 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsHandle);
346 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(paramHandle);
347 :
348 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsAppendPlaceHolder(argsHandle, paramHandle));
349 1 : return ACL_SUCCESS;
350 3 : }
351 :
352 5 : aclError aclrtKernelArgsGetPlaceHolderBufferImpl(
353 : aclrtArgsHandle argsHandle, aclrtParamHandle paramHandle, size_t dataSize, void** bufferAddr)
354 : {
355 5 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsGetPlaceHolderBuffer);
356 5 : ACL_LOG_INFO("Start to execute aclrtKernelArgsGetPlaceHolderBuffer");
357 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsHandle);
358 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(paramHandle);
359 6 : ACL_REQUIRES_POSITIVE_REPORT(dataSize);
360 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(bufferAddr);
361 :
362 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsGetPlaceHolderBuffer(argsHandle, paramHandle, dataSize, bufferAddr));
363 1 : return ACL_SUCCESS;
364 5 : }
365 :
366 6 : aclError aclrtKernelArgsParaUpdateImpl(
367 : aclrtArgsHandle argsHandle, aclrtParamHandle paramHandle, void* param, size_t paramSize)
368 : {
369 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtKernelArgsParaUpdate);
370 6 : ACL_LOG_INFO("Start to execute aclrtKernelArgsParaUpdate");
371 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsHandle);
372 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(paramHandle);
373 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(param);
374 6 : ACL_REQUIRES_POSITIVE_REPORT(paramSize);
375 :
376 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsParaUpdate(argsHandle, paramHandle, param, paramSize));
377 1 : return ACL_SUCCESS;
378 6 : }
379 :
380 2 : aclError aclrtKernelArgsFinalizeImpl(aclrtArgsHandle argsHandle)
381 : {
382 2 : ACL_LOG_INFO("Start to execute aclrtKernelArgsFinalize");
383 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsHandle);
384 :
385 2 : ACL_REQUIRES_RTS_OK(rtsKernelArgsFinalize(argsHandle));
386 1 : return ACL_SUCCESS;
387 : }
388 :
389 2 : aclError aclrtGetThreadLastTaskIdImpl(uint32_t* taskId)
390 : {
391 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetThreadLastTaskId);
392 2 : ACL_LOG_DEBUG("start to execute aclrtGetThreadLastTaskId");
393 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(taskId);
394 2 : ACL_REQUIRES_RTS_OK(rtsGetThreadLastTaskId(taskId));
395 1 : return ACL_SUCCESS;
396 2 : }
397 :
398 4 : aclError aclrtGetFunctionNameImpl(aclrtFuncHandle funcHandle, uint32_t maxLen, char* name)
399 : {
400 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetFunctionName);
401 4 : ACL_LOG_DEBUG("start to execute aclrtGetFunctionName, maxLen is [%u]", maxLen);
402 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(name);
403 2 : ACL_REQUIRES_RTS_OK(rtsFuncGetName(static_cast<rtFuncHandle>(funcHandle), maxLen, name));
404 1 : return ACL_SUCCESS;
405 4 : }
406 :
407 4 : aclError aclrtBinaryLoadFromDataImpl(
408 : const void* data, size_t length, const aclrtBinaryLoadOptions* options, aclrtBinHandle* binHandle)
409 : {
410 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtBinaryLoadFromData);
411 4 : ACL_LOG_DEBUG("start to execute aclrtBinaryLoadFromData, length is [%zu]", length);
412 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(data);
413 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(binHandle);
414 2 : ACL_REQUIRES_RTS_OK(rtsBinaryLoadFromData(
415 : data, length, reinterpret_cast<const rtLoadBinaryConfig_t*>(options), static_cast<rtBinHandle*>(binHandle)));
416 1 : return ACL_SUCCESS;
417 4 : }
418 :
419 6 : aclError aclrtRegisterCpuFuncImpl(
420 : const aclrtBinHandle handle, const char* funcName, const char* kernelName, aclrtFuncHandle* funcHandle)
421 : {
422 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtRegisterCpuFunc);
423 6 : ACL_LOG_DEBUG("start to execute aclrtRegisterCpuFunc");
424 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
425 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcName);
426 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(kernelName);
427 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
428 2 : ACL_REQUIRES_RTS_OK(rtsRegisterCpuFunc(
429 : static_cast<rtBinHandle>(handle), funcName, kernelName, static_cast<rtFuncHandle*>(funcHandle)));
430 1 : return ACL_SUCCESS;
431 6 : }
432 :
433 5 : aclError aclrtCmoWaitBarrierImpl(aclrtBarrierTaskInfo* taskInfo, aclrtStream stream, uint32_t flag)
434 : {
435 5 : ACL_PROFILING_REG(acl::AclProfType::AclrtCmoWaitBarrier);
436 5 : ACL_LOG_DEBUG("start to execute aclrtCmoWaitBarrier, flag is [%u]", flag);
437 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(taskInfo);
438 4 : if ((taskInfo->barrierNum == 0U) || (taskInfo->barrierNum > ACL_RT_CMO_MAX_BARRIER_NUM)) {
439 2 : ACL_LOG_ERROR(
440 : "[Check][taskInfo]param taskInfo is invalid, taskInfo->barrierNum must be in range (0, %d]",
441 : ACL_RT_CMO_MAX_BARRIER_NUM);
442 2 : const std::string barrierNumVal = std::to_string(taskInfo->barrierNum);
443 2 : const std::string expect = acl::AclErrorLogManager::FormatStr("(0, %d]", ACL_RT_CMO_MAX_BARRIER_NUM);
444 2 : std::string funcName = acl::AclErrorLogManager::GetFuncNameWithoutImplSuffix(__func__);
445 2 : acl::AclErrorLogManager::ReportInputError(
446 4 : acl::INVALID_VALUE_MSG, std::vector<const char*>({"func", "value", "param", "expect"}),
447 2 : std::vector<const char*>(
448 4 : {funcName.c_str(), barrierNumVal.c_str(), "taskInfo->barrierNum", expect.c_str()}));
449 2 : return ACL_ERROR_INVALID_PARAM;
450 2 : }
451 : rtBarrierTaskInfo_t rtTaskInfo;
452 2 : rtTaskInfo.logicIdNum = taskInfo->barrierNum;
453 4 : for (size_t i = 0U; i < taskInfo->barrierNum; i++) {
454 2 : rtTaskInfo.cmoInfo[i].cmoType =
455 2 : static_cast<uint16_t>(taskInfo->cmoInfo[i].cmoType) +
456 : (static_cast<uint16_t>(RT_CMO_PREFETCH) - static_cast<uint16_t>(ACL_RT_CMO_TYPE_PREFETCH));
457 2 : rtTaskInfo.cmoInfo[i].logicId = taskInfo->cmoInfo[i].barrierId;
458 : }
459 2 : ACL_REQUIRES_RTS_OK(rtsLaunchBarrierTask(&rtTaskInfo, static_cast<rtStream_t>(stream), flag));
460 1 : return ACL_SUCCESS;
461 5 : }
462 :
463 6 : aclError aclrtLaunchKernelV2Impl(
464 : aclrtFuncHandle funcHandle, uint32_t numBlocks, const void* argsData, size_t argsSize, aclrtLaunchKernelCfg* cfg,
465 : aclrtStream stream)
466 : {
467 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchKernelV2);
468 6 : ACL_LOG_INFO("Start to execute aclrtLaunchKernelV2");
469 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
470 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(argsData);
471 :
472 4 : rtKernelLaunchCfg_t* rt_cfg = nullptr;
473 4 : if (cfg != nullptr) {
474 1 : rt_cfg = reinterpret_cast<rtKernelLaunchCfg_t*>(cfg);
475 : }
476 :
477 4 : const rtError_t rtErr = rtsLaunchKernelWithDevArgs(
478 : funcHandle, numBlocks, stream, rt_cfg, argsData, static_cast<uint32_t>(argsSize), nullptr);
479 4 : if (rtErr != RT_ERROR_NONE) {
480 2 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
481 1 : ACL_LOG_WARN("rtsLaunchKernelWithDevArgs funHandle is invalid, runtime result = %d.", rtErr);
482 1 : return ACL_ERROR_RT_INVALID_HANDLE;
483 : } else {
484 1 : return ACL_GET_ERRCODE_RTS(rtErr);
485 : }
486 : }
487 :
488 2 : return ACL_SUCCESS;
489 6 : }
490 :
491 6 : aclError aclrtLaunchKernelWithHostArgsImpl(
492 : aclrtFuncHandle funcHandle, uint32_t numBlocks, aclrtStream stream, aclrtLaunchKernelCfg* cfg, void* hostArgs,
493 : size_t argsSize, aclrtPlaceHolderInfo* placeHolderArray, size_t placeHolderNum)
494 : {
495 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchKernelWithHostArgs);
496 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
497 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(hostArgs);
498 :
499 4 : rtKernelLaunchCfg_t* rt_cfg = nullptr;
500 4 : rtPlaceHolderInfo_t* rt_placeHolderArray = nullptr;
501 4 : if (cfg != nullptr) {
502 1 : rt_cfg = reinterpret_cast<rtKernelLaunchCfg_t*>(cfg);
503 : }
504 :
505 4 : if (placeHolderArray != nullptr) {
506 1 : rt_placeHolderArray = reinterpret_cast<rtPlaceHolderInfo_t*>(placeHolderArray);
507 : }
508 :
509 4 : const rtError_t rtErr = rtsLaunchKernelWithHostArgs(
510 : funcHandle, numBlocks, stream, rt_cfg, hostArgs, static_cast<uint32_t>(argsSize), rt_placeHolderArray,
511 : placeHolderNum);
512 4 : if (rtErr != RT_ERROR_NONE) {
513 2 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
514 1 : ACL_LOG_WARN("rtsLaunchKernelWithHostArgs funHandle is invalid, runtime result = %d.", rtErr);
515 1 : return ACL_ERROR_RT_INVALID_HANDLE;
516 : } else {
517 1 : return ACL_GET_ERRCODE_RTS(rtErr);
518 : }
519 : }
520 :
521 2 : return ACL_SUCCESS;
522 6 : }
523 :
524 7 : aclError aclrtLaunchKernelWithArgsArrayImpl(
525 : void* func, uint32_t numBlocks, aclrtStream stream, aclrtLaunchKernelCfg* cfg, void** args)
526 : {
527 7 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchKernelWithArgsArray);
528 7 : ACL_LOG_INFO("Start to execute aclrtLaunchKernelWithArgsArray");
529 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(func);
530 9 : ACL_REQUIRES_POSITIVE_REPORT(numBlocks);
531 :
532 5 : rtKernelLaunchCfg_t* rt_cfg = nullptr;
533 5 : if (cfg != nullptr) {
534 4 : rt_cfg = reinterpret_cast<rtKernelLaunchCfg_t*>(cfg);
535 : }
536 :
537 5 : const rtError_t rtErr = rtLaunchKernelWithArgsArray(func, numBlocks, stream, rt_cfg, args);
538 5 : if (rtErr != ACL_RT_SUCCESS) {
539 3 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
540 1 : ACL_LOG_WARN("rtLaunchKernelWithArgsArray func is invalid, runtime result = %d.", rtErr);
541 1 : return ACL_ERROR_RT_INVALID_HANDLE;
542 2 : } else if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
543 1 : ACL_LOG_WARN("rtLaunchKernelWithArgsArray does not support, runtime result = %d.", rtErr);
544 1 : return ACL_ERROR_RT_FEATURE_NOT_SUPPORT;
545 : } else {
546 1 : return ACL_GET_ERRCODE_RTS(rtErr);
547 : }
548 : }
549 2 : return ACL_SUCCESS;
550 7 : }
551 :
552 5 : aclError aclrtLaunchSIMTKernelWithArgsArrayImpl(
553 : void* func, aclrtDim3 gridDim, aclrtDim3 blockDim, size_t dynUbufSize, aclrtStream stream,
554 : aclrtLaunchKernelCfg* cfg, void** args)
555 : {
556 5 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchSIMTKernelWithArgsArray);
557 5 : ACL_LOG_INFO("Start to execute aclrtLaunchSIMTKernelWithArgsArray");
558 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(func);
559 :
560 4 : rtDim3 rtGridDim = {gridDim.x, gridDim.y, gridDim.z};
561 4 : rtDim3 rtBlockDim = {blockDim.x, blockDim.y, blockDim.z};
562 4 : rtKernelLaunchCfg_t* rt_cfg = reinterpret_cast<rtKernelLaunchCfg_t*>(cfg);
563 : const rtError_t rtErr =
564 4 : rtLaunchSIMTKernelWithArgsArray(func, rtGridDim, rtBlockDim, dynUbufSize, stream, rt_cfg, args);
565 4 : if (rtErr != ACL_RT_SUCCESS) {
566 3 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
567 1 : ACL_LOG_WARN("rtLaunchSIMTKernelWithArgsArray func is invalid, runtime result = %d.", rtErr);
568 1 : return ACL_ERROR_RT_INVALID_HANDLE;
569 2 : } else if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
570 1 : ACL_LOG_WARN("rtLaunchSIMTKernelWithArgsArray not support, runtime result = %d.", rtErr);
571 1 : return ACL_ERROR_RT_FEATURE_NOT_SUPPORT;
572 : } else {
573 1 : return ACL_GET_ERRCODE_RTS(rtErr);
574 : }
575 : }
576 1 : return ACL_SUCCESS;
577 5 : }
578 :
579 2 : aclError aclrtGetFloatOverflowStatusImpl(void* outputAddr, uint64_t outputSize, aclrtStream stream)
580 : {
581 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetFloatOverflowStatus);
582 2 : ACL_LOG_INFO("start to execute aclrtGetFloatOverflowStatus, outputSize = %lu", outputSize);
583 2 : ACL_REQUIRES_RTS_OK(rtsGetFloatOverflowStatus(outputAddr, outputSize, static_cast<rtStream_t>(stream)));
584 1 : ACL_LOG_INFO("successfully execute aclrtGetFloatOverflowStatus");
585 1 : return ACL_SUCCESS;
586 2 : }
587 :
588 7 : aclError aclrtLaunchSIMTKernelWithHostArgsImpl(
589 : void* func, aclrtDim3 gridDim, aclrtDim3 blockDim, size_t dynUbufSize, aclrtStream stream,
590 : aclrtLaunchKernelCfg* cfg, void* hostArgs, size_t argsSize, aclrtPlaceHolderInfo* placeHolderArray,
591 : size_t placeHolderNum)
592 : {
593 7 : ACL_PROFILING_REG(acl::AclProfType::AclrtLaunchSIMTKernelWithHostArgs);
594 7 : ACL_LOG_INFO("Start to execute aclrtLaunchSIMTKernelWithHostArgs");
595 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(func);
596 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(hostArgs);
597 8 : ACL_REQUIRES_POSITIVE_REPORT(argsSize);
598 :
599 4 : rtDim3 rtGridDim = {gridDim.x, gridDim.y, gridDim.z};
600 4 : rtDim3 rtBlockDim = {blockDim.x, blockDim.y, blockDim.z};
601 4 : rtKernelLaunchCfg_t* rtCfg = reinterpret_cast<rtKernelLaunchCfg_t*>(cfg);
602 4 : rtPlaceHolderInfo_t* rtPlaceHolder = reinterpret_cast<rtPlaceHolderInfo_t*>(placeHolderArray);
603 4 : const rtError_t rtErr = rtLaunchSIMTKernelWithHostArgs(
604 : func, rtGridDim, rtBlockDim, dynUbufSize, stream, rtCfg, hostArgs, static_cast<uint32_t>(argsSize),
605 : rtPlaceHolder, static_cast<uint32_t>(placeHolderNum));
606 4 : if (rtErr != ACL_RT_SUCCESS) {
607 3 : if (rtErr == ACL_ERROR_RT_INVALID_HANDLE) {
608 1 : ACL_LOG_WARN("rtLaunchSIMTKernelWithHostArgs func is invalid, runtime result = %d.", rtErr);
609 1 : return ACL_ERROR_RT_INVALID_HANDLE;
610 2 : } else if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
611 1 : ACL_LOG_WARN("rtLaunchSIMTKernelWithHostArgs not support, runtime result = %d.", rtErr);
612 1 : return ACL_ERROR_RT_FEATURE_NOT_SUPPORT;
613 : } else {
614 1 : return ACL_GET_ERRCODE_RTS(rtErr);
615 : }
616 : }
617 1 : return ACL_SUCCESS;
618 7 : }
619 :
620 2 : aclError aclrtResetFloatOverflowStatusImpl(aclrtStream stream)
621 : {
622 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtResetFloatOverflowStatus);
623 2 : ACL_LOG_INFO("start to execute aclrtResetFloatOverflowStatus");
624 2 : ACL_REQUIRES_RTS_OK(rtsResetFloatOverflowStatus(static_cast<rtStream_t>(stream)));
625 1 : ACL_LOG_INFO("successfully execute aclrtResetFloatOverflowStatus");
626 1 : return ACL_SUCCESS;
627 2 : }
628 :
629 2 : aclError aclrtNpuGetFloatOverFlowStatusImpl(
630 : void* outputAddr, uint64_t outputSize, uint32_t checkMode, aclrtStream stream)
631 : {
632 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtNpuGetFloatOverFlowStatus);
633 2 : ACL_LOG_INFO("start to execute aclrtNpuGetFloatOverFlowStatus, outputSize = %lu", outputSize);
634 2 : ACL_REQUIRES_RTS_OK(
635 : rtsNpuGetFloatOverFlowStatus(outputAddr, outputSize, checkMode, static_cast<rtStream_t>(stream)));
636 1 : ACL_LOG_INFO("successfully execute aclrtNpuGetFloatOverFlowStatus");
637 1 : return ACL_SUCCESS;
638 2 : }
639 :
640 2 : aclError aclrtNpuClearFloatOverFlowStatusImpl(uint32_t checkMode, aclrtStream stream)
641 : {
642 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtNpuClearFloatOverFlowStatus);
643 2 : ACL_LOG_INFO("start to execute aclrtNpuClearFloatOverFlowStatus");
644 2 : ACL_REQUIRES_RTS_OK(rtsNpuClearFloatOverFlowStatus(checkMode, static_cast<rtStream_t>(stream)));
645 1 : ACL_LOG_INFO("successfully execute aclrtNpuClearFloatOverFlowStatus");
646 1 : return ACL_SUCCESS;
647 2 : }
648 :
649 2 : aclError aclrtGetHardwareSyncAddrImpl(void** addr)
650 : {
651 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetHardwareSyncAddr);
652 2 : ACL_REQUIRES_RTS_OK(rtsGetHardwareSyncAddr(addr));
653 1 : return ACL_SUCCESS;
654 2 : }
655 :
656 4 : aclError aclrtRandomNumAsyncImpl(const aclrtRandomNumTaskInfo* taskInfo, const aclrtStream stream, void* reserve)
657 : {
658 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtRandomNumAsync);
659 4 : ACL_LOG_INFO("start to execute aclrtRandomNumAsync");
660 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(taskInfo);
661 3 : aclDataType type = taskInfo->dataType;
662 3 : if (kMapDataType.count(type) == 0) {
663 1 : ACL_LOG_ERROR("[Check][param]param dataType [%d] is invalid.", static_cast<int32_t>(type));
664 1 : std::string funcName = acl::AclErrorLogManager::GetFuncNameWithoutImplSuffix(__func__);
665 1 : acl::AclErrorLogManager::ReportInputError(
666 2 : acl::INVALID_PARAM_REASON_MSG, std::vector<const char*>({"func", "value", "param", "reason"}),
667 1 : std::vector<const char*>(
668 1 : {funcName.c_str(), acl::GetDataTypeDesc(type), "taskInfo->dataType",
669 2 : "The data type is currently not supported"}));
670 1 : return ACL_ERROR_INVALID_PARAM;
671 1 : }
672 2 : rtRandomNumTaskInfo_t* rtTaskInfo =
673 : const_cast<rtRandomNumTaskInfo_t*>(reinterpret_cast<const rtRandomNumTaskInfo_t*>(taskInfo));
674 2 : rtTaskInfo->dataType = kMapDataType.at(type);
675 2 : ACL_REQUIRES_RTS_OK(rtsLaunchRandomNumTask(rtTaskInfo, static_cast<rtStream_t>(stream), reserve));
676 1 : ACL_LOG_INFO("successfully execute aclrtRandomNumAsync");
677 1 : return ACL_SUCCESS;
678 4 : }
679 :
680 7 : aclError aclrtTaskUpdateAsyncImpl(
681 : aclrtStream taskStream, uint32_t taskId, aclrtTaskUpdateInfo* info, aclrtStream execStream)
682 : {
683 7 : ACL_PROFILING_REG(acl::AclProfType::AclrtTaskUpdateAsync);
684 7 : ACL_LOG_INFO("start to execute aclrtTaskUpdateAsync");
685 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(info);
686 6 : ACL_REQUIRES_RTS_OK(rtsLaunchUpdateTask(
687 : static_cast<rtStream_t>(taskStream), taskId, static_cast<rtStream_t>(execStream),
688 : reinterpret_cast<rtTaskUpdateCfg_t*>(info)));
689 5 : ACL_LOG_INFO("successfully execute aclrtTaskUpdateAsync");
690 5 : return ACL_SUCCESS;
691 7 : }
692 :
693 5 : aclError aclrtCacheLastTaskOpInfoImpl(const void* const infoPtr, const size_t infoSize)
694 : {
695 5 : ACL_PROFILING_REG(acl::AclProfType::AclrtCacheLastTaskOpInfo);
696 5 : ACL_LOG_INFO("start to execute aclrtCacheLastTaskOpInfo");
697 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(infoPtr);
698 7 : ACL_REQUIRES_POSITIVE_REPORT(infoSize);
699 :
700 3 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtCacheLastTaskOpInfo(infoPtr, infoSize), rtCacheLastTaskOpInfo);
701 1 : ACL_LOG_INFO("successfully execute aclrtCacheLastTaskOpInfo");
702 1 : return ACL_SUCCESS;
703 5 : }
704 :
705 3 : aclError aclrtCacheLastTaskExtendInfoImpl(const char* const extendInfoPtr, const size_t infoSize)
706 : {
707 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtCacheLastTaskExtendInfo);
708 3 : ACL_LOG_INFO("start to execute aclrtCacheLastTaskExtendInfo");
709 :
710 3 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtCacheLastTaskExtendInfo(extendInfoPtr, infoSize), rtCacheLastTaskExtendInfo);
711 1 : ACL_LOG_INFO("successfully execute aclrtCacheLastTaskExtendInfo");
712 1 : return ACL_SUCCESS;
713 3 : }
714 :
715 3 : aclError aclrtGetFunctionAttributeImpl(aclrtFuncHandle funcHandle, aclrtFuncAttribute attrType, int64_t* attrValue)
716 : {
717 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetFunctionAttribute);
718 3 : ACL_LOG_INFO("start to execute aclrtGetFunctionAttribute");
719 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(funcHandle);
720 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(attrValue);
721 :
722 1 : ACL_REQUIRES_RTS_OK(rtFunctionGetAttribute(funcHandle, static_cast<rtFuncAttribute>(attrType), attrValue));
723 :
724 0 : ACL_LOG_INFO("successfully execute aclrtGetFunctionAttribute");
725 0 : return ACL_SUCCESS;
726 3 : }
727 :
728 2 : aclError aclmdlRITaskGetSeqIdImpl(aclmdlRITask task, uint32_t* id)
729 : {
730 2 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRITaskGetSeqId);
731 :
732 2 : ACL_REQUIRES_RTS_OK(rtTaskGetSeqId(static_cast<rtTask_t>(task), id));
733 1 : return ACL_SUCCESS;
734 2 : }
735 :
736 2 : aclError aclrtFunctionGetBinaryImpl(const aclrtFuncHandle funcHandle, aclrtBinHandle* binHandle)
737 : {
738 2 : ACL_REQUIRES_RTS_OK(rtFunctionGetBinary(funcHandle, binHandle));
739 1 : return ACL_SUCCESS;
740 : }
741 :
742 5 : aclError aclrtFunctionGetParamCountImpl(const void* func, size_t* paramCount)
743 : {
744 5 : ACL_LOG_INFO("start to execute aclrtFunctionGetParamCount");
745 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(func);
746 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(paramCount);
747 3 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(rtFunctionGetParamCount(func, paramCount), rtFunctionGetParamCount);
748 1 : ACL_LOG_INFO("successfully execute aclrtFunctionGetParamCount, paramCount=%zu.", *paramCount);
749 1 : return ACL_SUCCESS;
750 : }
751 :
752 5 : aclError aclrtFunctionGetParamInfoImpl(const void* func, size_t paramIndex, size_t* paramOffset, size_t* paramSize)
753 : {
754 5 : ACL_LOG_INFO("start to execute aclrtFunctionGetParamInfo, paramIndex=%zu.", paramIndex);
755 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(func);
756 4 : if ((paramOffset == nullptr) && (paramSize == nullptr)) {
757 1 : ACL_LOG_ERROR("[Check][paramOffset,paramSize]paramOffset and paramSize cannot both be null.");
758 4 : acl::AclErrorLogManager::ReportInputError(
759 : acl::INVALID_NULL_POINTER_AT_SAME_TIME_MSG, {"func", "param"},
760 : {"aclrtFunctionGetParamInfo", "paramOffset and paramSize"});
761 1 : return ACL_ERROR_INVALID_PARAM;
762 : }
763 3 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(
764 : rtFunctionGetParamInfo(func, paramIndex, paramOffset, paramSize), rtFunctionGetParamInfo);
765 1 : ACL_LOG_INFO("successfully execute aclrtFunctionGetParamInfo.");
766 1 : return ACL_SUCCESS;
767 : }
768 :
769 8 : aclError aclrtFunctionGetAvailDynUbufPerBlockImpl(void* func, uint32_t flags, size_t* dynamicUbufSize)
770 : {
771 8 : ACL_LOG_INFO("start to execute aclrtFunctionGetAvailDynUbufPerBlock.");
772 8 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(func);
773 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(dynamicUbufSize);
774 9 : ACL_REQUIRES_PARAM_EQUAL_REPORT(flags, 0U);
775 :
776 5 : ACL_REQUIRES_RTS_OK_WARN_NOT_SUPPORT(
777 : rtFunctionGetAvailDynUbufPerBlock(func, flags, dynamicUbufSize), rtFunctionGetAvailDynUbufPerBlock);
778 2 : ACL_LOG_INFO("successfully execute aclrtFunctionGetAvailDynUbufPerBlock, dynamicUbufSize=%zu.", *dynamicUbufSize);
779 2 : return ACL_SUCCESS;
780 : }
781 :
782 2 : aclError aclmdlRITaskGetTypeImpl(aclmdlRITask task, aclmdlRITaskType* type)
783 : {
784 2 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRITaskGetType);
785 :
786 2 : ACL_REQUIRES_RTS_OK(rtTaskGetType(static_cast<rtTask_t>(task), reinterpret_cast<rtTaskType*>(type)));
787 :
788 1 : return ACL_SUCCESS;
789 2 : }
790 : #ifdef __cplusplus
791 : }
792 : #endif
|
