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 <unordered_map>
12 : #include "acl_rt_impl.h"
13 :
14 : #include "runtime/stream.h"
15 : #include "runtime/rts/rts_stream.h"
16 :
17 : #include "common/log_inner.h"
18 : #include "common/error_codes_inner.h"
19 : #include "common/prof_reporter.h"
20 : #include "common/resource_statistics.h"
21 :
22 : namespace {
23 : std::unordered_map<rtError_t, const char *> succStmSyncErrCodes = {
24 : {ACL_ERROR_RT_END_OF_SEQUENCE, "end of sequence"},
25 : {ACL_ERROR_RT_MODEL_ABORT_NORMAL, "model abort normal"},
26 : {ACL_ERROR_RT_AICORE_OVER_FLOW, "aicore overflow"},
27 : {ACL_ERROR_RT_AIVEC_OVER_FLOW, "aivec overflow"},
28 : {ACL_ERROR_RT_OVER_FLOW, "overflow"},
29 : {ACL_ERROR_RT_SOCKET_CLOSE, "socket close"}};
30 : }
31 :
32 11 : aclError aclrtCreateStreamImpl(aclrtStream *stream)
33 : {
34 22 : ACL_PROFILING_REG(acl::AclProfType::AclrtCreateStream);
35 11 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_STREAM);
36 11 : ACL_LOG_INFO("start to execute aclrtCreateStream");
37 11 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
38 :
39 8 : rtStream_t rtStream = nullptr;
40 8 : const rtError_t rtErr = rtStreamCreate(&rtStream, static_cast<int32_t>(RT_STREAM_PRIORITY_DEFAULT));
41 8 : if (rtErr != RT_ERROR_NONE) {
42 3 : ACL_LOG_CALL_ERROR("create stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
43 3 : return ACL_GET_ERRCODE_RTS(rtErr);
44 : }
45 :
46 5 : *stream = static_cast<aclrtStream>(rtStream);
47 5 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_STREAM);
48 5 : return ACL_SUCCESS;
49 : }
50 :
51 9 : aclError aclrtCreateStreamWithConfigImpl(aclrtStream *stream, uint32_t priority, uint32_t flag)
52 : {
53 18 : ACL_PROFILING_REG(acl::AclProfType::AclrtCreateStreamWithConfig);
54 9 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_STREAM);
55 9 : ACL_LOG_INFO("start to execute aclrtCreateStreamWithConfig with priority:%u, flag:%u", priority, flag);
56 9 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
57 :
58 8 : uint32_t streamFlag = 0U;
59 8 : if ((flag & ACL_STREAM_FAST_LAUNCH) != 0U) {
60 2 : streamFlag |= RT_STREAM_FAST_LAUNCH;
61 : }
62 8 : if ((flag & ACL_STREAM_FAST_SYNC) != 0U) {
63 1 : streamFlag |= RT_STREAM_FAST_SYNC;
64 : }
65 8 : if ((flag & ACL_STREAM_PERSISTENT) != 0U) {
66 1 : streamFlag |= RT_STREAM_PERSISTENT;
67 : }
68 8 : if ((flag & ACL_STREAM_HUGE) != 0U) {
69 1 : streamFlag |= RT_STREAM_HUGE;
70 : }
71 8 : if ((flag & ACL_STREAM_CPU_SCHEDULE) != 0U) {
72 1 : streamFlag |= RT_STREAM_CPU_SCHEDULE;
73 : }
74 8 : if ((flag & ACL_STREAM_DEVICE_USE_ONLY) != 0U) {
75 3 : streamFlag |= RT_STREAM_CP_PROCESS_USE;
76 : }
77 :
78 8 : rtStream_t rtStream = nullptr;
79 8 : constexpr size_t numAttrs = 2;
80 8 : rtStreamCreateAttr_t attrs[numAttrs];
81 8 : attrs[0].id = RT_STREAM_CREATE_ATTR_PRIORITY;
82 8 : attrs[0].value.priority = priority;
83 8 : attrs[1].id = RT_STREAM_CREATE_ATTR_FLAGS;
84 8 : attrs[1].value.flags = streamFlag;
85 8 : rtStreamCreateConfig_t config = {attrs, numAttrs};
86 8 : const rtError_t rtErr = rtsStreamCreate(&rtStream, &config);
87 8 : if (rtErr != RT_ERROR_NONE) {
88 0 : ACL_LOG_CALL_ERROR("create stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
89 0 : return ACL_GET_ERRCODE_RTS(rtErr);
90 : }
91 :
92 8 : *stream = static_cast<aclrtStream>(rtStream);
93 8 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_STREAM);
94 8 : return ACL_SUCCESS;
95 : }
96 :
97 6 : aclError aclrtDestroyStreamImpl(aclrtStream stream)
98 : {
99 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtDestroyStream);
100 6 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_STREAM);
101 6 : ACL_LOG_INFO("start to execute aclrtDestroyStream");
102 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
103 :
104 4 : const rtError_t rtErr = rtStreamDestroy(static_cast<rtStream_t>(stream));
105 4 : if (rtErr != RT_ERROR_NONE) {
106 2 : ACL_LOG_CALL_ERROR("destroy stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
107 2 : return ACL_GET_ERRCODE_RTS(rtErr);
108 : }
109 2 : ACL_LOG_INFO("aclrtDestroyStream success");
110 2 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_STREAM);
111 2 : return ACL_SUCCESS;
112 : }
113 :
114 6 : aclError aclrtDestroyStreamForceImpl(aclrtStream stream)
115 : {
116 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtDestroyStreamForce);
117 6 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_STREAM);
118 6 : ACL_LOG_INFO("start to execute aclrtDestroyStreamForce");
119 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
120 :
121 4 : const rtError_t rtErr = rtStreamDestroyForce(static_cast<rtStream_t>(stream));
122 4 : if (rtErr != RT_ERROR_NONE) {
123 2 : ACL_LOG_CALL_ERROR("destroy stream force failed, runtime result = %d", static_cast<int32_t>(rtErr));
124 2 : return ACL_GET_ERRCODE_RTS(rtErr);
125 : }
126 2 : ACL_LOG_INFO("aclrtDestroyStreamForce success");
127 2 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_STREAM);
128 2 : return ACL_SUCCESS;
129 : }
130 :
131 7 : aclError aclrtSynchronizeStreamImpl(aclrtStream stream)
132 : {
133 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtSynchronizeStream);
134 :
135 7 : const rtError_t rtErr = rtStreamSynchronize(static_cast<rtStream_t>(stream));
136 7 : if (rtErr != RT_ERROR_NONE) {
137 3 : const auto it = succStmSyncErrCodes.find(rtErr);
138 3 : if (it == succStmSyncErrCodes.cend()) {
139 2 : ACL_LOG_CALL_ERROR("synchronize stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
140 : } else {
141 1 : ACL_LOG_INFO("Synchronize stream success, err = %d, desc = %s",
142 : static_cast<int32_t>(rtErr), it->second);
143 : }
144 3 : return ACL_GET_ERRCODE_RTS(rtErr);
145 : }
146 :
147 4 : return ACL_SUCCESS;
148 : }
149 :
150 6 : aclError aclrtSynchronizeStreamWithTimeoutImpl(aclrtStream stream, int32_t timeout)
151 : {
152 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtSynchronizeStreamWithTimeout);
153 6 : constexpr int32_t default_timeout = -1;
154 6 : if (timeout < default_timeout) {
155 1 : ACL_LOG_CALL_ERROR("the timeout of synchronize stream is invalid");
156 1 : return ACL_ERROR_RT_PARAM_INVALID;
157 : }
158 5 : const rtError_t rtErr = rtStreamSynchronizeWithTimeout(static_cast<rtStream_t>(stream), timeout);
159 5 : if (rtErr == ACL_ERROR_RT_STREAM_SYNC_TIMEOUT) {
160 1 : ACL_LOG_CALL_ERROR("synchronize stream timeout, timeout = %dms", timeout);
161 1 : return ACL_ERROR_RT_STREAM_SYNC_TIMEOUT;
162 : }
163 4 : if (rtErr != RT_ERROR_NONE) {
164 2 : const auto it = succStmSyncErrCodes.find(rtErr);
165 2 : if (it == succStmSyncErrCodes.cend()) {
166 1 : ACL_LOG_CALL_ERROR("synchronize stream with timeout failed, runtime result = %d",
167 : static_cast<int32_t>(rtErr));
168 : } else {
169 1 : ACL_LOG_INFO("synchronize stream with timeout success, err = %d, desc = %s",
170 : static_cast<int32_t>(rtErr), it->second);
171 : }
172 2 : return ACL_GET_ERRCODE_RTS(rtErr);
173 : }
174 :
175 2 : return ACL_SUCCESS;
176 : }
177 :
178 4 : aclError aclrtStreamQueryImpl(aclrtStream stream, aclrtStreamStatus *status)
179 : {
180 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtStreamQuery);
181 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(status);
182 :
183 3 : const rtError_t rtErr = rtStreamQuery(static_cast<rtStream_t>(stream));
184 3 : if (rtErr == RT_ERROR_NONE) {
185 1 : *status = ACL_STREAM_STATUS_COMPLETE;
186 2 : } else if (rtErr == ACL_ERROR_RT_STREAM_NOT_COMPLETE) {
187 1 : *status = ACL_STREAM_STATUS_NOT_READY;
188 : } else {
189 1 : ACL_LOG_CALL_ERROR("stream query failed, runtime result = %d", static_cast<int32_t>(rtErr));
190 1 : return ACL_GET_ERRCODE_RTS(rtErr);
191 : }
192 :
193 2 : return ACL_SUCCESS;
194 : }
195 :
196 4 : aclError aclrtStreamGetPriorityImpl(aclrtStream stream, uint32_t *priority)
197 : {
198 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtStreamGetPriority);
199 4 : ACL_LOG_INFO("start to execute aclrtStreamGetPriority");
200 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(priority);
201 3 : rtStream_t rtStream = static_cast<rtStream_t>(stream);
202 3 : uint32_t prio = 0U;
203 3 : const rtError_t rtErr = rtStreamGetPriority(rtStream, &prio);
204 3 : if (rtErr != RT_ERROR_NONE) {
205 1 : ACL_LOG_CALL_ERROR("get stream priority failed, runtime result = %d", static_cast<int32_t>(rtErr));
206 1 : return ACL_GET_ERRCODE_RTS(rtErr);
207 : }
208 2 : *priority = prio;
209 2 : ACL_LOG_INFO("successfully execute aclrtStreamGetPriority, priority is %u", *priority);
210 2 : return ACL_SUCCESS;
211 : }
212 :
213 4 : aclError aclrtStreamGetFlagsImpl(aclrtStream stream, uint32_t *flags)
214 : {
215 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtStreamGetFlags);
216 4 : ACL_LOG_INFO("start to execute aclrtStreamGetFlags");
217 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(flags);
218 3 : rtStream_t rtStream = static_cast<rtStream_t>(stream);
219 3 : uint32_t rtFlags = 0U;
220 3 : const rtError_t rtErr = rtStreamGetFlags(rtStream, &rtFlags);
221 3 : if (rtErr != RT_ERROR_NONE) {
222 1 : ACL_LOG_CALL_ERROR("get stream flags failed, runtime result = %d", static_cast<int32_t>(rtErr));
223 1 : return ACL_GET_ERRCODE_RTS(rtErr);
224 : }
225 2 : uint32_t aclFlags = 0U;
226 2 : if ((rtFlags & RT_STREAM_FAST_LAUNCH) != 0U) {
227 1 : aclFlags |= ACL_STREAM_FAST_LAUNCH;
228 : }
229 2 : if ((rtFlags & RT_STREAM_FAST_SYNC) != 0U) {
230 0 : aclFlags |= ACL_STREAM_FAST_SYNC;
231 : }
232 2 : if ((rtFlags & RT_STREAM_PERSISTENT) != 0U) {
233 0 : aclFlags |= ACL_STREAM_PERSISTENT;
234 : }
235 2 : if ((rtFlags & RT_STREAM_HUGE) != 0U) {
236 0 : aclFlags |= ACL_STREAM_HUGE;
237 : }
238 2 : if ((rtFlags & RT_STREAM_CPU_SCHEDULE) != 0U) {
239 0 : aclFlags |= ACL_STREAM_CPU_SCHEDULE;
240 : }
241 2 : if ((rtFlags & RT_STREAM_CP_PROCESS_USE) != 0U) {
242 0 : aclFlags |= ACL_STREAM_DEVICE_USE_ONLY;
243 : }
244 2 : *flags = aclFlags;
245 2 : ACL_LOG_INFO("successfully execute aclrtStreamGetFlags, rtFlags is %#x, aclFlags is %#x", rtFlags, *flags);
246 2 : return ACL_SUCCESS;
247 : }
248 :
249 6 : aclError aclrtStreamWaitEventImpl(aclrtStream stream, aclrtEvent event)
250 : {
251 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtStreamWaitEvent);
252 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(event);
253 :
254 6 : const rtError_t rtErr = rtStreamWaitEvent(static_cast<rtStream_t>(stream), static_cast<rtEvent_t>(event));
255 6 : if (rtErr != RT_ERROR_NONE) {
256 2 : ACL_LOG_CALL_ERROR("stream wait event failed, runtime result = %d", static_cast<int32_t>(rtErr));
257 2 : return ACL_GET_ERRCODE_RTS(rtErr);
258 : }
259 :
260 4 : return ACL_SUCCESS;
261 : }
262 :
263 8 : aclError aclrtSetStreamFailureModeImpl(aclrtStream stream, uint64_t mode)
264 : {
265 16 : ACL_PROFILING_REG(acl::AclProfType::AclrtSetStreamFailureMode);
266 8 : ACL_LOG_INFO("start to execute aclrtSetStreamFailureMode, mode is %lu", mode);
267 8 : const rtError_t rtErr = rtStreamSetMode(static_cast<rtStream_t>(stream), mode);
268 8 : if (rtErr != RT_ERROR_NONE) {
269 4 : ACL_LOG_CALL_ERROR("rtSetStreamFailureMode failed, runtime result = %d.", rtErr);
270 4 : return ACL_GET_ERRCODE_RTS(rtErr);
271 : }
272 4 : ACL_LOG_INFO("successfully execute aclrtSetStreamFailureMode, mode is %lu", mode);
273 4 : return ACL_SUCCESS;
274 : }
275 :
276 2 : aclError aclrtGetStreamOverflowSwitchImpl(aclrtStream stream, uint32_t *flag)
277 : {
278 2 : ACL_LOG_INFO("start to execute aclrtGetStreamOverflowSwitch");
279 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(flag);
280 2 : const rtError_t rtErr = rtGetStreamOverflowSwitch(static_cast<rtStream_t>(stream), flag);
281 2 : if (rtErr != RT_ERROR_NONE) {
282 1 : ACL_LOG_CALL_ERROR("rtGetStreamOverflowSwitch failed, runtime result = %d.", rtErr);
283 1 : return ACL_GET_ERRCODE_RTS(rtErr);
284 : }
285 1 : ACL_LOG_INFO("successfully execute aclrtGetStreamOverflowSwitch, flag is %d.", *flag);
286 1 : return ACL_SUCCESS;
287 : }
288 :
289 2 : aclError aclrtSetStreamOverflowSwitchImpl(aclrtStream stream, uint32_t flag)
290 : {
291 2 : ACL_LOG_INFO("start to execute aclrtSetStreamOverflowSwitch, flag is %u.", flag);
292 2 : if ((flag != 0U) && ((flag != 1U))) {
293 0 : ACL_LOG_ERROR("flag must be 1 or 0, but current value is %u", flag);
294 0 : return ACL_ERROR_INVALID_PARAM;
295 : }
296 2 : const rtError_t rtErr = rtSetStreamOverflowSwitch(static_cast<rtStream_t>(stream), flag);
297 2 : if (rtErr != RT_ERROR_NONE) {
298 1 : ACL_LOG_CALL_ERROR("rtSetStreamOverflowSwitch failed, runtime result = %d.", rtErr);
299 1 : return ACL_GET_ERRCODE_RTS(rtErr);
300 : }
301 1 : ACL_LOG_INFO("successfully execute rtSetStreamOverflowSwitch, flag is %u.", flag);
302 1 : return ACL_SUCCESS;
303 : }
304 :
305 3 : aclError aclrtStreamAbortImpl(aclrtStream stream)
306 : {
307 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtStreamAbort);
308 3 : ACL_LOG_INFO("start to execute aclrtStreamAbort");
309 3 : const rtError_t rtErr = rtStreamAbort(stream);
310 3 : if (rtErr != RT_ERROR_NONE) {
311 1 : ACL_LOG_CALL_ERROR("abort stream failed, runtime result = %d", static_cast<int32_t>(rtErr));
312 1 : return ACL_GET_ERRCODE_RTS(rtErr);
313 : }
314 :
315 2 : ACL_LOG_INFO("successfully execute aclrtStreamAbort");
316 2 : return ACL_SUCCESS;
317 : }
318 :
319 2 : aclError aclrtStreamGetIdImpl(aclrtStream stream, int32_t *streamId)
320 : {
321 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtStreamGetId);
322 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(streamId);
323 2 : const rtError_t rtErr = rtsStreamGetId(static_cast<rtStream_t>(stream), streamId);
324 2 : if (rtErr != RT_ERROR_NONE) {
325 1 : ACL_LOG_CALL_ERROR("call rtsStreamGetId failed, runtime result = %d", rtErr);
326 1 : return ACL_GET_ERRCODE_RTS(rtErr);
327 : }
328 1 : return ACL_SUCCESS;
329 : }
330 :
331 3 : aclError aclrtGetStreamAvailableNumImpl(uint32_t *streamCount)
332 : {
333 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetStreamAvailableNum);
334 3 : ACL_LOG_INFO("start to execute aclrtGetStreamAvailableNum");
335 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(streamCount);
336 :
337 2 : const rtError_t rtErr = rtsStreamGetAvailableNum(streamCount);
338 2 : if (rtErr != RT_ERROR_NONE) {
339 1 : ACL_LOG_CALL_ERROR("call rtsStreamGetAvailableNum failed, runtime result = %d", rtErr);
340 1 : return ACL_GET_ERRCODE_RTS(rtErr);
341 : }
342 :
343 1 : ACL_LOG_INFO("successfully execute aclrtGetStreamAvailableNum");
344 1 : return ACL_SUCCESS;
345 : }
346 :
347 4 : aclError aclrtSetStreamAttributeImpl(aclrtStream stream, aclrtStreamAttr stmAttrType, aclrtStreamAttrValue *value)
348 : {
349 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtSetStreamAttribute);
350 4 : ACL_LOG_INFO("start to execute aclrtSetStreamAttribute, stmAttrType = [%u]", static_cast<uint32_t>(stmAttrType));
351 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(value);
352 :
353 2 : const rtError_t rtErr = rtsStreamSetAttribute(static_cast<rtStream_t>(stream),
354 : static_cast<rtStreamAttr>(stmAttrType),
355 : reinterpret_cast<rtStreamAttrValue_t*>(value)
356 : );
357 2 : if (rtErr != RT_ERROR_NONE) {
358 1 : ACL_LOG_CALL_ERROR("call rtsStreamSetAttribute failed, runtime result = %d", rtErr);
359 1 : return ACL_GET_ERRCODE_RTS(rtErr);
360 : }
361 :
362 1 : ACL_LOG_INFO("successfully execute aclrtSetStreamAttribute");
363 1 : return ACL_SUCCESS;
364 : }
365 :
366 4 : aclError aclrtGetStreamAttributeImpl(aclrtStream stream, aclrtStreamAttr stmAttrType, aclrtStreamAttrValue *value)
367 : {
368 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetStreamAttribute);
369 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(value);
370 :
371 2 : const rtError_t rtErr = rtsStreamGetAttribute(static_cast<rtStream_t>(stream),
372 : static_cast<rtStreamAttr>(stmAttrType),
373 : reinterpret_cast<rtStreamAttrValue_t*>(value)
374 : );
375 2 : if (rtErr != RT_ERROR_NONE) {
376 1 : ACL_LOG_CALL_ERROR("call rtsStreamGetAttribute failed, runtime result = %d", rtErr);
377 1 : return ACL_GET_ERRCODE_RTS(rtErr);
378 : }
379 :
380 1 : return ACL_SUCCESS;
381 : }
382 :
383 4 : aclError aclrtActiveStreamImpl(aclrtStream activeStream, aclrtStream stream)
384 : {
385 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtActiveStream);
386 4 : ACL_LOG_INFO("start to execute aclrtActiveStream");
387 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(activeStream);
388 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
389 :
390 2 : const rtError_t rtErr = rtsActiveStream(static_cast<rtStream_t>(activeStream), static_cast<rtStream_t>(stream));
391 2 : if (rtErr != RT_ERROR_NONE) {
392 1 : ACL_LOG_CALL_ERROR("call rtsActiveStream failed, runtime result = %d", rtErr);
393 1 : return ACL_GET_ERRCODE_RTS(rtErr);
394 : }
395 :
396 1 : ACL_LOG_INFO("successfully execute aclrtActiveStream");
397 1 : return ACL_SUCCESS;
398 : }
399 :
400 7 : aclError aclrtSwitchStreamImpl(void *leftValue, aclrtCondition cond, void *rightValue, aclrtCompareDataType dataType,
401 : aclrtStream trueStream, aclrtStream falseStream, aclrtStream stream)
402 : {
403 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtSwitchStream);
404 7 : ACL_LOG_INFO("start to execute aclrtSwitchStream, cond is [%u], dataType is [%u]",
405 : static_cast<uint32_t>(cond), static_cast<uint32_t>(dataType));
406 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(leftValue);
407 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(rightValue);
408 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(trueStream);
409 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
410 3 : if (falseStream != nullptr) {
411 1 : ACL_LOG_ERROR("param falseStream must be nullptr currently.");
412 1 : return ACL_ERROR_INVALID_PARAM;
413 : }
414 :
415 2 : const rtError_t rtErr = rtsSwitchStream(leftValue, static_cast<rtCondition_t>(cond), rightValue,
416 : static_cast<rtSwitchDataType_t>(dataType), static_cast<rtStream_t>(trueStream),
417 : static_cast<rtStream_t>(falseStream), static_cast<rtStream_t>(stream));
418 2 : if (rtErr != RT_ERROR_NONE) {
419 1 : ACL_LOG_CALL_ERROR("call rtsSwitchStream failed, runtime result = %d", rtErr);
420 1 : return ACL_GET_ERRCODE_RTS(rtErr);
421 : }
422 :
423 1 : ACL_LOG_INFO("successfully execute aclrtSwitchStream");
424 1 : return ACL_SUCCESS;
425 : }
426 :
427 3 : aclError aclrtStreamStopImpl(aclrtStream stream)
428 : {
429 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtStreamStop);
430 3 : ACL_LOG_INFO("start to execute aclrtStreamStop");
431 :
432 3 : const rtError_t rtErr = rtsStreamStop(static_cast<rtStream_t>(stream));
433 3 : if (rtErr != RT_ERROR_NONE) {
434 1 : ACL_LOG_CALL_ERROR("call rtsStreamStop failed, runtime result = %d.", static_cast<int32_t>(rtErr));
435 1 : return ACL_GET_ERRCODE_RTS(rtErr);
436 : }
437 2 : ACL_LOG_INFO("successfully execute aclrtStreamStop");
438 2 : return ACL_SUCCESS;
439 : }
440 :
441 3 : aclError aclrtPersistentTaskCleanImpl(aclrtStream stream)
442 : {
443 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtPersistentTaskClean);
444 3 : ACL_LOG_INFO("start to execute aclrtPersistentTaskClean");
445 :
446 3 : const rtError_t rtErr = rtsPersistentTaskClean(static_cast<rtStream_t>(stream));
447 3 : if (rtErr != RT_ERROR_NONE) {
448 1 : ACL_LOG_CALL_ERROR("call rtsPersistentTaskClean failed, runtime result = %d.", static_cast<int32_t>(rtErr));
449 1 : return ACL_GET_ERRCODE_RTS(rtErr);
450 : }
451 2 : ACL_LOG_INFO("successfully execute aclrtPersistentTaskClean");
452 2 : return ACL_SUCCESS;
453 : }
|
