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 "acl_rt_impl_base.h"
13 :
14 : #include "runtime/context.h"
15 : #include "runtime/rts/rts_context.h"
16 : #include "runtime/dev.h"
17 : #include "runtime/config.h"
18 :
19 : #include "common/log_inner.h"
20 : #include "common/error_codes_inner.h"
21 : #include "common/prof_reporter.h"
22 : #include "common/resource_statistics.h"
23 :
24 7 : aclError aclrtCreateContextImpl(aclrtContext *context, int32_t deviceId)
25 : {
26 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtCreateContext);
27 7 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_CONTEXT);
28 7 : ACL_LOG_INFO("start to execute aclrtCreateContext, device is %d.", deviceId);
29 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(context);
30 :
31 5 : rtContext_t rtCtx = nullptr;
32 5 : const rtError_t rtErr = rtCtxCreateEx(&rtCtx, static_cast<uint32_t>(RT_CTX_NORMAL_MODE), deviceId);
33 5 : if (rtErr != RT_ERROR_NONE) {
34 2 : ACL_LOG_CALL_ERROR("create context failed, device is %d, runtime errorCode is %d",
35 : deviceId, static_cast<int32_t>(rtErr));
36 2 : return ACL_GET_ERRCODE_RTS(rtErr);
37 : }
38 3 : ACL_LOG_INFO("successfully execute aclrtCreateContext, device is %d.", deviceId);
39 3 : *context = static_cast<aclrtContext>(rtCtx);
40 3 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_CONTEXT);
41 :
42 : // update platform info
43 3 : const auto err = acl::UpdatePlatformInfoWithDevice(deviceId);
44 3 : if (err != ACL_SUCCESS) {
45 1 : ACL_LOG_WARN("update platform info with device failed, error code is [%d], deviceId is [%d]", err, deviceId);
46 : }
47 3 : return ACL_SUCCESS;
48 : }
49 :
50 6 : aclError aclrtDestroyContextImpl(aclrtContext context)
51 : {
52 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtDestroyContext);
53 6 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_CONTEXT);
54 6 : ACL_LOG_INFO("start to execute aclrtDestroyContext.");
55 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(context);
56 :
57 4 : const rtError_t rtErr = rtCtxDestroyEx(static_cast<rtContext_t>(context));
58 4 : if (rtErr != RT_ERROR_NONE) {
59 2 : ACL_LOG_CALL_ERROR("destory context failed, runtime errorCode is %d", static_cast<int32_t>(rtErr));
60 2 : return ACL_GET_ERRCODE_RTS(rtErr);
61 : }
62 2 : ACL_LOG_INFO("successfully execute aclrtDestroyContext");
63 2 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_CONTEXT);
64 2 : return ACL_SUCCESS;
65 : }
66 :
67 6 : aclError aclrtSetCurrentContextImpl(aclrtContext context)
68 : {
69 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtSetCurrentContext);
70 6 : ACL_LOG_INFO("start to execute aclrtSetCurrentContext.");
71 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(context);
72 :
73 4 : const rtError_t rtErr = rtCtxSetCurrent(static_cast<rtContext_t>(context));
74 4 : if (rtErr != RT_ERROR_NONE) {
75 2 : ACL_LOG_CALL_ERROR("set current context failed, runtime errorCode is %d", static_cast<int32_t>(rtErr));
76 2 : return ACL_GET_ERRCODE_RTS(rtErr);
77 : }
78 2 : ACL_LOG_INFO("successfully execute aclrtSetCurrentContext");
79 2 : return ACL_SUCCESS;
80 : }
81 :
82 6 : aclError aclrtGetCurrentContextImpl(aclrtContext *context)
83 : {
84 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetCurrentContext);
85 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(context);
86 :
87 4 : rtContext_t rtCtx = nullptr;
88 4 : const rtError_t rtErr = rtCtxGetCurrent(&rtCtx);
89 4 : if (rtErr != RT_ERROR_NONE) {
90 2 : ACL_LOG_INFO("can not get current context, runtime errorCode is %d", static_cast<int32_t>(rtErr));
91 2 : return ACL_GET_ERRCODE_RTS(rtErr);
92 : }
93 :
94 2 : *context = rtCtx;
95 2 : return ACL_SUCCESS;
96 : }
97 :
98 13 : static aclError GetSysParamOpt(aclSysParamOpt opt, int64_t *value, bool isCtx)
99 : {
100 13 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(value);
101 11 : if (opt != ACL_OPT_DETERMINISTIC && opt != ACL_OPT_ENABLE_DEBUG_KERNEL && opt != ACL_OPT_STRONG_CONSISTENCY && opt != ACL_OPT_EARLY_START) {
102 2 : ACL_LOG_INNER_ERROR("[Check][SysParamOpt]opt = %d is invalid, it should be %d or %d or %d or %d",
103 : static_cast<int32_t>(opt), static_cast<int32_t>(ACL_OPT_DETERMINISTIC),
104 : static_cast<int32_t>(ACL_OPT_ENABLE_DEBUG_KERNEL),
105 : static_cast<int32_t>(ACL_OPT_STRONG_CONSISTENCY),
106 : static_cast<int32_t>(ACL_OPT_EARLY_START));
107 6 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
108 4 : std::vector<const char *>({"param", "value", "reason"}),
109 4 : std::vector<const char *>({"aclSysParamOpt", std::to_string(opt).c_str(), "must be 0 or 1 or 2 or 3"}));
110 2 : return ACL_ERROR_INVALID_PARAM;
111 : }
112 9 : rtError_t rtErr = RT_ERROR_NONE;
113 9 : if (isCtx) {
114 6 : rtErr = rtCtxGetSysParamOpt(static_cast<rtSysParamOpt>(opt), value);
115 : }
116 : else {
117 3 : rtErr = rtGetSysParamOpt(static_cast<rtSysParamOpt>(opt), value);
118 : }
119 9 : if (rtErr == ACL_ERROR_RT_SYSPARAMOPT_NOT_SET) {
120 3 : ACL_LOG_WARN("option %d is not set, runtime errorCode is %d",
121 : static_cast<int32_t>(opt), static_cast<int32_t>(rtErr));
122 3 : return ACL_GET_ERRCODE_RTS(rtErr);
123 : }
124 6 : if (rtErr != RT_ERROR_NONE) {
125 3 : ACL_LOG_CALL_ERROR("get sys param failed, runtime result = %d, opt = %d.",
126 : static_cast<int32_t>(rtErr), static_cast<int32_t>(opt));
127 3 : return ACL_GET_ERRCODE_RTS(rtErr);
128 : }
129 3 : ACL_LOG_INFO("successfully execute GetSysParamOpt, opt = %d, value = %ld",
130 : static_cast<int32_t>(opt), *value);
131 3 : return ACL_SUCCESS;
132 : }
133 :
134 8 : static aclError SetSysParamOpt(aclSysParamOpt opt, int64_t value, bool isCtx)
135 : {
136 8 : if (opt != ACL_OPT_DETERMINISTIC && opt != ACL_OPT_ENABLE_DEBUG_KERNEL && opt != ACL_OPT_STRONG_CONSISTENCY && opt != ACL_OPT_EARLY_START) {
137 2 : ACL_LOG_INNER_ERROR("[Check][SysParamOpt]opt = %d is invalid, it should be %d or %d or %d or %d",
138 : static_cast<int32_t>(opt), static_cast<int32_t>(ACL_OPT_DETERMINISTIC),
139 : static_cast<int32_t>(ACL_OPT_ENABLE_DEBUG_KERNEL),
140 : static_cast<int32_t>(ACL_OPT_STRONG_CONSISTENCY),
141 : static_cast<int32_t>(ACL_OPT_EARLY_START));
142 6 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
143 4 : std::vector<const char *>({"param", "value", "reason"}),
144 4 : std::vector<const char *>({"aclSysParamOpt", std::to_string(opt).c_str(), "should be 0 or 1 or 2 or 3"}));
145 2 : return ACL_ERROR_INVALID_PARAM;
146 : }
147 6 : rtError_t rtErr = RT_ERROR_NONE;
148 6 : if (isCtx) {
149 4 : rtErr = rtCtxSetSysParamOpt(static_cast<rtSysParamOpt>(opt), value);
150 : } else {
151 2 : rtErr = rtSetSysParamOpt(static_cast<rtSysParamOpt>(opt), value);
152 : }
153 6 : if (rtErr != RT_ERROR_NONE) {
154 3 : ACL_LOG_CALL_ERROR("set sys param failed, runtime result = %d, opt = %d.",
155 : static_cast<int32_t>(rtErr), static_cast<int32_t>(opt));
156 3 : return ACL_GET_ERRCODE_RTS(rtErr);
157 : }
158 3 : ACL_LOG_INFO("successfully execute aclrtCtxSetSysParamOpt");
159 3 : return ACL_SUCCESS;
160 : }
161 :
162 :
163 8 : aclError aclrtCtxGetSysParamOptImpl(aclSysParamOpt opt, int64_t *value)
164 : {
165 16 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetSysParamOpt);
166 16 : return GetSysParamOpt(opt, value, true);
167 : }
168 :
169 5 : aclError aclrtCtxSetSysParamOptImpl(aclSysParamOpt opt, int64_t value)
170 : {
171 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxSetSysParamOpt);
172 5 : ACL_LOG_INFO("start to execute aclrtCtxSetSysParamOpt, opt = %d, value = %ld.",
173 : static_cast<int32_t>(opt), value);
174 10 : return SetSysParamOpt(opt, value, true);
175 : }
176 :
177 5 : aclError aclrtGetSysParamOptImpl(aclSysParamOpt opt, int64_t *value)
178 : {
179 5 : return GetSysParamOpt(opt, value, false);
180 : }
181 :
182 3 : aclError aclrtSetSysParamOptImpl(aclSysParamOpt opt, int64_t value)
183 : {
184 3 : ACL_LOG_INFO("start to execute aclrtSetSysParamOpt, opt = %d, value = %ld.",
185 : static_cast<int32_t>(opt), value);
186 3 : return SetSysParamOpt(opt, value, false);
187 : }
188 :
189 2 : aclError aclrtPeekAtLastErrorImpl(aclrtLastErrLevel level)
190 : {
191 2 : ACL_LOG_INFO("start to execute aclrtPeekAtLastError, level is %d", static_cast<int32_t>(level));
192 2 : if (level != ACL_RT_THREAD_LEVEL) {
193 1 : ACL_LOG_ERROR("invalid input param level %d, only support ACL_RT_THREAD_LEVEL", static_cast<int32_t>(level));
194 1 : return ACL_ERROR_INVALID_PARAM;
195 : }
196 1 : const rtLastErrLevel_t rtLevel = static_cast<rtLastErrLevel_t>(level);
197 1 : return rtPeekAtLastError(rtLevel);
198 : }
199 :
200 2 : aclError aclrtGetLastErrorImpl(aclrtLastErrLevel level)
201 : {
202 2 : ACL_LOG_INFO("start to execute aclrtGetLastError, level is %d", static_cast<int32_t>(level));
203 2 : if (level != ACL_RT_THREAD_LEVEL) {
204 1 : ACL_LOG_ERROR("invalid input param level %d, only support ACL_RT_THREAD_LEVEL", static_cast<int32_t>(level));
205 1 : return ACL_ERROR_INVALID_PARAM;
206 : }
207 1 : const rtLastErrLevel_t rtLevel = static_cast<rtLastErrLevel_t>(level);
208 1 : return rtGetLastError(rtLevel);
209 : }
210 :
211 3 : aclError aclrtCtxGetCurrentDefaultStreamImpl(aclrtStream *stream)
212 : {
213 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetCurrentDefaultStream);
214 3 : ACL_LOG_INFO("start to execute aclrtCtxGetCurrentDefaultStream");
215 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
216 :
217 2 : const rtError_t rtErr = rtsCtxGetCurrentDefaultStream(stream);
218 2 : if (rtErr != RT_ERROR_NONE) {
219 1 : ACL_LOG_ERROR("call rtsCtxGetCurrentDefaultStream failed, runtime errorCode is %d",
220 : static_cast<int32_t>(rtErr));
221 1 : return ACL_GET_ERRCODE_RTS(rtErr);
222 : }
223 :
224 1 : ACL_LOG_INFO("successfully execute aclrtCtxGetCurrentDefaultStream");
225 1 : return ACL_SUCCESS;
226 : }
227 :
228 2 : aclError aclrtCtxGetFloatOverflowAddrImpl(void **overflowAddr)
229 : {
230 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetFloatOverflowAddr);
231 :
232 2 : const rtError_t rtErr = rtsCtxGetFloatOverflowAddr(overflowAddr);
233 2 : if (rtErr != RT_ERROR_NONE) {
234 1 : ACL_LOG_ERROR("call rtsCtxGetFloatOverflowAddr failed, runtime errorCode is %d",
235 : static_cast<int32_t>(rtErr));
236 1 : return ACL_GET_ERRCODE_RTS(rtErr);
237 : }
238 :
239 1 : return ACL_SUCCESS;
240 : }
241 :
242 4 : aclError aclrtGetPrimaryCtxStateImpl(int32_t deviceId, uint32_t *flags, int32_t *active)
243 : {
244 4 : ACL_LOG_INFO("start to execute aclrtGetPrimaryCtxState");
245 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(active);
246 3 : if (flags != nullptr) {
247 1 : ACL_LOG_ERROR("[Check][flags]paramete flags is reserved, it must be null.");
248 1 : const char_t *argList[] = {"param"};
249 1 : const char_t *argVal[] = {"flags"};
250 1 : acl::AclErrorLogManager::ReportInputErrorWithChar(acl::INVALID_PARAM_MSG,
251 : argList, argVal, 1U);
252 1 : return ACL_ERROR_INVALID_PARAM;
253 : }
254 2 : uint32_t tmp = 0;
255 2 : const rtError_t rtErr = rtsGetPrimaryCtxState(deviceId, &tmp, active);
256 2 : if (rtErr != RT_ERROR_NONE) {
257 1 : ACL_LOG_WARN("call aclrtGetPrimaryCtxState failed, runtime errorCode is %d, device id is %d",
258 : static_cast<int32_t>(rtErr), deviceId);
259 1 : return ACL_GET_ERRCODE_RTS(rtErr);
260 : }
261 1 : ACL_LOG_INFO("successfully execute aclrtGetPrimaryCtxState");
262 1 : return ACL_SUCCESS;
263 : }
|
