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