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