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