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