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