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