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 "runtime/rt_model.h"
13 : #include "runtime/stream.h"
14 : #include "runtime/rts/rts_model.h"
15 : #include "runtime/rts/rts_stream.h"
16 : #include "runtime/rt_inner_model.h"
17 : #include "common/log_inner.h"
18 : #include "common/error_codes_inner.h"
19 : #include "common/prof_reporter.h"
20 :
21 2 : aclError aclmdlRIExecuteAsyncImpl(aclmdlRI modelRI, aclrtStream stream)
22 : {
23 4 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIExecuteAsync);
24 2 : ACL_LOG_INFO("start to execute aclmdlRIExecuteAsync");
25 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
26 2 : const rtError_t rtErr = rtModelExecute(static_cast<rtModel_t>(modelRI), static_cast<rtStream_t>(stream), 0U);
27 2 : if (rtErr != RT_ERROR_NONE) {
28 1 : ACL_LOG_CALL_ERROR("execute rtModel failed, runtime result = %d", static_cast<int32_t>(rtErr));
29 1 : return ACL_GET_ERRCODE_RTS(rtErr);
30 : }
31 :
32 1 : ACL_LOG_INFO("successfully execute aclmdlRIExecuteAsync");
33 1 : return ACL_SUCCESS;
34 : }
35 :
36 2 : aclError aclmdlRIDestroyImpl(aclmdlRI modelRI)
37 : {
38 4 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIDestroy);
39 2 : ACL_LOG_INFO("start to execute aclmdlRIDestroy");
40 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
41 2 : const rtError_t rtErr = rtModelDestroy(static_cast<rtModel_t>(modelRI));
42 2 : if (rtErr != RT_ERROR_NONE) {
43 1 : ACL_LOG_CALL_ERROR("destroy rtModel failed, runtime result = %d", static_cast<int32_t>(rtErr));
44 1 : return ACL_GET_ERRCODE_RTS(rtErr);
45 : }
46 :
47 1 : ACL_LOG_INFO("successfully execute aclmdlRIDestroy");
48 1 : return ACL_SUCCESS;
49 : }
50 :
51 3 : aclError aclmdlRICaptureBeginImpl(aclrtStream stream, aclmdlRICaptureMode mode)
52 : {
53 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRICaptureBegin);
54 3 : ACL_LOG_INFO("start to execute aclmdlRICaptureBegin, mode is %d", static_cast<int32_t>(mode));
55 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
56 3 : const rtError_t rtErr = rtStreamBeginCapture(static_cast<rtStream_t>(stream),
57 : static_cast<rtStreamCaptureMode>(mode));
58 3 : if (rtErr != RT_ERROR_NONE) {
59 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
60 1 : ACL_LOG_WARN("begin capture stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
61 : } else {
62 1 : ACL_LOG_CALL_ERROR("begin capture stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
63 : }
64 2 : return ACL_GET_ERRCODE_RTS(rtErr);
65 : }
66 :
67 1 : ACL_LOG_INFO("successfully execute aclmdlRICaptureBegin");
68 1 : return ACL_SUCCESS;
69 : }
70 :
71 3 : aclError aclmdlRICaptureGetInfoImpl(aclrtStream stream, aclmdlRICaptureStatus *status, aclmdlRI *modelRI)
72 : {
73 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRICaptureGetInfo);
74 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
75 3 : if (status == nullptr && modelRI == nullptr) {
76 1 : ACL_LOG_INNER_ERROR("status and modelRI cannot be nullptr at the same time");
77 1 : return ACL_ERROR_INVALID_PARAM;
78 : }
79 2 : rtStreamCaptureStatus rtStatus = RT_STREAM_CAPTURE_STATUS_NONE;
80 2 : rtModel_t rtModel = nullptr;
81 2 : const rtError_t rtErr = rtStreamGetCaptureInfo(static_cast<rtStream_t>(stream), &rtStatus, &rtModel);
82 2 : if (rtErr != RT_ERROR_NONE) {
83 1 : return ACL_GET_ERRCODE_RTS(rtErr);
84 : }
85 :
86 1 : if (status != nullptr) {
87 1 : *status = static_cast<aclmdlRICaptureStatus>(static_cast<uint32_t>(rtStatus));
88 : }
89 :
90 1 : if (modelRI != nullptr) {
91 1 : *modelRI = static_cast<aclmdlRI>(rtModel);
92 : }
93 :
94 1 : return ACL_SUCCESS;
95 : }
96 :
97 3 : aclError aclmdlRICaptureEndImpl(aclrtStream stream, aclmdlRI *modelRI)
98 : {
99 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRICaptureEnd);
100 3 : ACL_LOG_INFO("start to execute aclmdlRICaptureEnd");
101 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
102 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
103 :
104 3 : rtModel_t rtModel = nullptr;
105 3 : const rtError_t rtErr = rtStreamEndCapture(static_cast<rtStream_t>(stream), &rtModel);
106 3 : if (rtErr != RT_ERROR_NONE) {
107 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
108 1 : ACL_LOG_WARN("end capture stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
109 : } else {
110 1 : ACL_LOG_CALL_ERROR("end capture stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
111 : }
112 2 : return ACL_GET_ERRCODE_RTS(rtErr);
113 : }
114 1 : *modelRI = static_cast<aclmdlRI>(rtModel);
115 :
116 1 : ACL_LOG_INFO("successfully execute aclmdlRICaptureEnd");
117 1 : return ACL_SUCCESS;
118 : }
119 :
120 2 : aclError aclmdlRIDebugPrintImpl(aclmdlRI modelRI)
121 : {
122 4 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIDebugPrint);
123 2 : ACL_LOG_INFO("start to execute aclmdlRIDebugPrint");
124 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
125 2 : const rtError_t rtErr = rtModelDebugDotPrint(static_cast<rtStream_t>(modelRI));
126 2 : if (rtErr != RT_ERROR_NONE) {
127 1 : ACL_LOG_CALL_ERROR("print model debug info failed, runtime result = %d", static_cast<int32_t>(rtErr));
128 1 : return ACL_GET_ERRCODE_RTS(rtErr);
129 : }
130 1 : ACL_LOG_INFO("successfully execute aclmdlRIDebugPrint");
131 1 : return ACL_SUCCESS;
132 : }
133 :
134 2 : aclError aclmdlRIDebugJsonPrintImpl(aclmdlRI modelRI, const char *path, uint32_t flags)
135 : {
136 4 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIDebugJsonPrint);
137 2 : ACL_LOG_INFO("start to execute aclmdlRIDebugJsonPrint");
138 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
139 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(path);
140 2 : const rtError_t rtErr = rtModelDebugJsonPrint(static_cast<rtStream_t>(modelRI), path, flags);
141 2 : if (rtErr != RT_ERROR_NONE) {
142 1 : ACL_LOG_CALL_ERROR("print model debug info failed, runtime result = %d", static_cast<int32_t>(rtErr));
143 1 : return ACL_GET_ERRCODE_RTS(rtErr);
144 : }
145 1 : ACL_LOG_INFO("successfully execute aclmdlRIDebugJsonPrint");
146 1 : return ACL_SUCCESS;
147 : }
148 :
149 3 : aclError aclmdlRICaptureThreadExchangeModeImpl(aclmdlRICaptureMode *mode)
150 : {
151 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRICaptureThreadExchangeMode);
152 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(mode);
153 3 : ACL_LOG_INFO("start to execute aclmdlRICaptureThreadExchangeMode, input mode is %d", static_cast<int32_t>(*mode));
154 3 : rtStreamCaptureMode rtMode = static_cast<rtStreamCaptureMode>(*mode);
155 3 : const rtError_t rtErr = rtThreadExchangeCaptureMode(&rtMode);
156 3 : if (rtErr != RT_ERROR_NONE) {
157 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
158 1 : ACL_LOG_WARN("exchange capture mode failed, runtime result = %d", static_cast<int32_t>(rtErr));
159 : } else {
160 1 : ACL_LOG_CALL_ERROR("exchange capture mode failed, runtime result = %d", static_cast<int32_t>(rtErr));
161 : }
162 2 : return ACL_GET_ERRCODE_RTS(rtErr);
163 : }
164 1 : *mode = static_cast<aclmdlRICaptureMode>(rtMode);
165 :
166 1 : ACL_LOG_INFO("successfully execute aclmdlRICaptureThreadExchangeMode, output mode is %d",
167 : static_cast<int32_t>(*mode));
168 1 : return ACL_SUCCESS;
169 : }
170 :
171 3 : aclError aclmdlRICaptureTaskGrpBeginImpl(aclrtStream stream)
172 : {
173 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRICaptureTaskGrpBegin);
174 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
175 3 : ACL_LOG_INFO("start to execute aclmdlRICaptureTaskGrpBegin");
176 3 : const rtError_t rtErr = rtsStreamBeginTaskGrp(static_cast<rtStream_t>(stream));
177 3 : if (rtErr != RT_ERROR_NONE) {
178 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
179 1 : ACL_LOG_WARN("begin capture task group failed, runtime result = %d", static_cast<int32_t>(rtErr));
180 : } else {
181 1 : ACL_LOG_CALL_ERROR("begin capture task group failed, runtime result = %d", static_cast<int32_t>(rtErr));
182 : }
183 2 : return ACL_GET_ERRCODE_RTS(rtErr);
184 : }
185 :
186 1 : ACL_LOG_INFO("successfully execute aclmdlRICaptureTaskGrpBegin");
187 1 : return ACL_SUCCESS;
188 : }
189 :
190 3 : aclError aclmdlRICaptureTaskGrpEndImpl(aclrtStream stream, aclrtTaskGrp *handle)
191 : {
192 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRICaptureTaskGrpEnd);
193 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
194 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
195 3 : ACL_LOG_INFO("start to execute aclmdlRICaptureTaskGrpEnd");
196 3 : rtTaskGrp_t rtHandle = nullptr;
197 3 : const rtError_t rtErr = rtsStreamEndTaskGrp(static_cast<rtStream_t>(stream), &rtHandle);
198 3 : if (rtErr != RT_ERROR_NONE) {
199 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
200 1 : ACL_LOG_WARN("end capture task group failed, runtime result = %d", static_cast<int32_t>(rtErr));
201 : } else {
202 1 : ACL_LOG_CALL_ERROR("end capture task group failed, runtime result = %d", static_cast<int32_t>(rtErr));
203 : }
204 2 : return ACL_GET_ERRCODE_RTS(rtErr);
205 : }
206 1 : *handle = static_cast<aclrtTaskGrp>(rtHandle);
207 :
208 1 : ACL_LOG_INFO("successfully execute aclmdlRICaptureTaskGrpEnd");
209 1 : return ACL_SUCCESS;
210 : }
211 :
212 3 : aclError aclmdlRICaptureTaskUpdateBeginImpl(aclrtStream stream, aclrtTaskGrp handle)
213 : {
214 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRICaptureTaskUpdateBegin);
215 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
216 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
217 3 : ACL_LOG_INFO("start to execute aclmdlRICaptureTaskUpdateBegin");
218 3 : const rtError_t rtErr = rtsStreamBeginTaskUpdate(static_cast<rtStream_t>(stream), static_cast<rtTaskGrp_t>(handle));
219 3 : if (rtErr != RT_ERROR_NONE) {
220 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
221 1 : ACL_LOG_WARN("begin update capture task group failed, runtime result = %d", static_cast<int32_t>(rtErr));
222 : } else {
223 1 : ACL_LOG_CALL_ERROR("begin update capture task group failed, runtime result = %d",
224 : static_cast<int32_t>(rtErr));
225 : }
226 2 : return ACL_GET_ERRCODE_RTS(rtErr);
227 : }
228 :
229 1 : ACL_LOG_INFO("successfully execute aclmdlRICaptureTaskUpdateBegin");
230 1 : return ACL_SUCCESS;
231 : }
232 :
233 3 : aclError aclmdlRICaptureTaskUpdateEndImpl(aclrtStream stream)
234 : {
235 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRICaptureTaskUpdateEnd);
236 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
237 3 : ACL_LOG_INFO("start to execute aclmdlRICaptureTaskUpdateEnd");
238 3 : const rtError_t rtErr = rtsStreamEndTaskUpdate(static_cast<rtStream_t>(stream));
239 3 : if (rtErr != RT_ERROR_NONE) {
240 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
241 1 : ACL_LOG_WARN("end update capture task group failed, runtime result = %d", static_cast<int32_t>(rtErr));
242 : } else {
243 1 : ACL_LOG_CALL_ERROR("end update capture task group failed, runtime result = %d",
244 : static_cast<int32_t>(rtErr));
245 : }
246 2 : return ACL_GET_ERRCODE_RTS(rtErr);
247 : }
248 :
249 1 : ACL_LOG_INFO("successfully execute aclmdlRICaptureTaskUpdateEnd");
250 1 : return ACL_SUCCESS;
251 : }
252 :
253 3 : aclError aclmdlRIBuildBeginImpl(aclmdlRI *modelRI, uint32_t flag)
254 : {
255 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIBuildBegin);
256 3 : ACL_LOG_INFO("start to execute aclmdlRIBuildBegin, flag is [%u]", flag);
257 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
258 :
259 2 : const rtError_t rtErr = rtsModelCreate(static_cast<rtModel_t*>(modelRI), flag);
260 2 : if (rtErr != RT_ERROR_NONE) {
261 1 : ACL_LOG_CALL_ERROR("call rtsModelCreate failed, runtime result = %d", static_cast<int32_t>(rtErr));
262 1 : return ACL_GET_ERRCODE_RTS(rtErr);
263 : }
264 :
265 1 : ACL_LOG_INFO("successfully execute aclmdlRIBuildBegin");
266 1 : return ACL_SUCCESS;
267 : }
268 :
269 3 : aclError aclmdlRIBindStreamImpl(aclmdlRI modelRI, aclrtStream stream, uint32_t flag)
270 : {
271 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIBindStream);
272 3 : ACL_LOG_INFO("start to execute aclmdlRIBindStream, flag is [%u].", flag);
273 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
274 :
275 2 : const rtError_t rtErr = rtsModelBindStream(static_cast<rtModel_t>(modelRI), static_cast<rtStream_t>(stream), flag);
276 2 : if (rtErr != RT_ERROR_NONE) {
277 1 : ACL_LOG_CALL_ERROR("call rtsModelBindStream failed, runtime result = %d", static_cast<int32_t>(rtErr));
278 1 : return ACL_GET_ERRCODE_RTS(rtErr);
279 : }
280 :
281 1 : ACL_LOG_INFO("successfully execute aclmdlRIBindStream");
282 1 : return ACL_SUCCESS;
283 : }
284 :
285 3 : aclError aclmdlRIEndTaskImpl(aclmdlRI modelRI, aclrtStream stream)
286 : {
287 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIEndTask);
288 3 : ACL_LOG_INFO("start to execute aclmdlRIEndTask");
289 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
290 :
291 2 : const rtError_t rtErr = rtsEndGraph(static_cast<rtModel_t>(modelRI), static_cast<rtStream_t>(stream));
292 2 : if (rtErr != RT_ERROR_NONE) {
293 1 : ACL_LOG_CALL_ERROR("call rtsEndGraph failed, runtime result = %d", static_cast<int32_t>(rtErr));
294 1 : return ACL_GET_ERRCODE_RTS(rtErr);
295 : }
296 :
297 1 : ACL_LOG_INFO("successfully execute aclmdlRIEndTask");
298 1 : return ACL_SUCCESS;
299 : }
300 :
301 4 : aclError aclmdlRIBuildEndImpl(aclmdlRI modelRI, void *reserve)
302 : {
303 8 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIBuildEnd);
304 4 : ACL_LOG_INFO("start to execute aclmdlRIBuildEnd");
305 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
306 3 : if (reserve != nullptr) {
307 1 : ACL_LOG_ERROR("[Check][reserve]param must be null.");
308 1 : acl::AclErrorLogManager::ReportInputError("EH0002", {"param"}, {"reserve"});
309 1 : return ACL_ERROR_INVALID_PARAM;
310 : }
311 :
312 2 : const rtError_t rtErr = rtsModelLoadComplete(static_cast<rtModel_t>(modelRI), reserve);
313 2 : if (rtErr != RT_ERROR_NONE) {
314 1 : ACL_LOG_CALL_ERROR("call rtsModelLoadComplete failed, runtime result = %d", static_cast<int32_t>(rtErr));
315 1 : return ACL_GET_ERRCODE_RTS(rtErr);
316 : }
317 :
318 1 : ACL_LOG_INFO("successfully execute aclmdlRIBuildEnd");
319 1 : return ACL_SUCCESS;
320 : }
321 :
322 3 : aclError aclmdlRIUnbindStreamImpl(aclmdlRI modelRI, aclrtStream stream)
323 : {
324 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIUnbindStream);
325 3 : ACL_LOG_INFO("start to execute aclmdlRIUnbindStream");
326 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
327 :
328 2 : const rtError_t rtErr = rtsModelUnbindStream(static_cast<rtModel_t>(modelRI), static_cast<rtStream_t>(stream));
329 2 : if (rtErr != RT_ERROR_NONE) {
330 1 : ACL_LOG_CALL_ERROR("call rtsModelUnbindStream failed, runtime result = %d", static_cast<int32_t>(rtErr));
331 1 : return ACL_GET_ERRCODE_RTS(rtErr);
332 : }
333 :
334 1 : ACL_LOG_INFO("successfully execute aclmdlRIUnbindStream");
335 1 : return ACL_SUCCESS;
336 : }
337 :
338 3 : aclError aclmdlRIExecuteImpl(aclmdlRI modelRI, int32_t timeout)
339 : {
340 6 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIExecute);
341 3 : ACL_LOG_INFO("start to execute aclmdlRIExecute, timeout is [%d] ms.", timeout);
342 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
343 :
344 2 : const rtError_t rtErr = rtsModelExecute(static_cast<rtModel_t>(modelRI), timeout);
345 2 : if (rtErr != RT_ERROR_NONE) {
346 1 : ACL_LOG_CALL_ERROR("call rtsModelExecute failed, runtime result = %d", static_cast<int32_t>(rtErr));
347 1 : return ACL_GET_ERRCODE_RTS(rtErr);
348 : }
349 :
350 1 : ACL_LOG_INFO("successfully execute aclmdlRIExecute");
351 1 : return ACL_SUCCESS;
352 : }
353 :
354 4 : aclError aclmdlRISetNameImpl(aclmdlRI modelRI, const char *name)
355 : {
356 8 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRISetName);
357 4 : ACL_LOG_INFO("start to execute aclmdlRISetName");
358 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
359 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(name);
360 :
361 2 : const rtError_t rtErr = rtsModelSetName(static_cast<rtModel_t>(modelRI), name);
362 2 : if (rtErr != RT_ERROR_NONE) {
363 1 : ACL_LOG_CALL_ERROR("call rtsModelSetName failed, runtime result = %d", static_cast<int32_t>(rtErr));
364 1 : return ACL_GET_ERRCODE_RTS(rtErr);
365 : }
366 :
367 1 : ACL_LOG_INFO("successfully execute aclmdlRISetName");
368 1 : return ACL_SUCCESS;
369 : }
370 :
371 4 : aclError aclmdlRIGetNameImpl(aclmdlRI modelRI, uint32_t maxLen, char *name)
372 : {
373 8 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIGetName);
374 4 : ACL_LOG_INFO("start to execute aclmdlRIGetName, maxLen is [%u]", maxLen);
375 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(modelRI);
376 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(name);
377 :
378 2 : const rtError_t rtErr = rtsModelGetName(static_cast<rtModel_t>(modelRI), maxLen, name);
379 2 : if (rtErr != RT_ERROR_NONE) {
380 1 : ACL_LOG_CALL_ERROR("call rtsModelGetName failed, runtime result = %d", static_cast<int32_t>(rtErr));
381 1 : return ACL_GET_ERRCODE_RTS(rtErr);
382 : }
383 :
384 1 : ACL_LOG_INFO("successfully execute aclmdlRIGetName");
385 1 : return ACL_SUCCESS;
386 : }
387 :
388 2 : aclError aclmdlRIAbortImpl(aclmdlRI modelRI)
389 : {
390 4 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIAbort);
391 2 : ACL_LOG_INFO("start to execute aclmdlRIAbort");
392 :
393 2 : const rtError_t rtErr = rtsModelAbort(static_cast<rtModel_t>(modelRI));
394 2 : if (rtErr != RT_ERROR_NONE) {
395 1 : ACL_LOG_CALL_ERROR("call aclmdlRIAbort failed, runtime result = %d", static_cast<int32_t>(rtErr));
396 1 : return ACL_GET_ERRCODE_RTS(rtErr);
397 : }
398 :
399 1 : ACL_LOG_INFO("successfully execute aclmdlRIAbort");
400 1 : return ACL_SUCCESS;
401 : }
402 :
403 2 : aclError aclmdlRIDestroyRegisterCallbackImpl(aclmdlRI modelRI, aclrtCallback func, void *userData) {
404 4 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIDestroyRegisterCallback);
405 2 : const rtError_t rtErr = rtModelDestroyRegisterCallback(static_cast<rtModel_t>(modelRI),
406 : reinterpret_cast<rtCallback_t>(func), userData);
407 2 : if (rtErr != RT_ERROR_NONE) {
408 1 : ACL_LOG_CALL_ERROR("call rtModelDestroyRegisterCallback failed, runtime result = %d", static_cast<int32_t>(rtErr));
409 1 : return ACL_GET_ERRCODE_RTS(rtErr);
410 : }
411 :
412 1 : return ACL_SUCCESS;
413 : }
414 :
415 2 : aclError aclmdlRIDestroyUnregisterCallbackImpl(aclmdlRI modelRI, aclrtCallback func) {
416 4 : ACL_PROFILING_REG(acl::AclProfType::AclmdlRIDestroyUnregisterCallback);
417 2 : const rtError_t rtErr = rtModelDestroyUnregisterCallback(static_cast<rtModel_t>(modelRI),
418 : reinterpret_cast<rtCallback_t>(func));
419 2 : if (rtErr != RT_ERROR_NONE) {
420 1 : ACL_LOG_CALL_ERROR("call rtModelDestroyUnregisterCallback failed, runtime result = %d", static_cast<int32_t>(rtErr));
421 1 : return ACL_GET_ERRCODE_RTS(rtErr);
422 : }
423 :
424 1 : return ACL_SUCCESS;
425 : }
|
