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 : #include "utils/data_type_utils.h"
24 :
25 : #ifdef __cplusplus
26 : extern "C" {
27 : #endif
28 :
29 7 : aclError aclrtCreateContextImpl(aclrtContext* context, int32_t deviceId)
30 : {
31 7 : ACL_PROFILING_REG(acl::AclProfType::AclrtCreateContext);
32 7 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_CONTEXT);
33 7 : ACL_LOG_INFO("start to execute aclrtCreateContext, device is %d.", deviceId);
34 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(context);
35 :
36 5 : rtContext_t rtCtx = nullptr;
37 5 : ACL_REQUIRES_RTS_OK(rtCtxCreateEx(&rtCtx, static_cast<uint32_t>(RT_CTX_NORMAL_MODE), deviceId));
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 7 : }
49 :
50 6 : aclError aclrtDestroyContextImpl(aclrtContext context)
51 : {
52 6 : 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 : ACL_REQUIRES_RTS_OK(rtCtxDestroyEx(static_cast<rtContext_t>(context)));
58 2 : ACL_LOG_INFO("successfully execute aclrtDestroyContext");
59 2 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_CREATE_DESTROY_CONTEXT);
60 2 : return ACL_SUCCESS;
61 6 : }
62 :
63 6 : aclError aclrtSetCurrentContextImpl(aclrtContext context)
64 : {
65 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtSetCurrentContext);
66 6 : ACL_LOG_INFO("start to execute aclrtSetCurrentContext.");
67 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(context);
68 :
69 4 : ACL_REQUIRES_RTS_OK(rtCtxSetCurrent(static_cast<rtContext_t>(context)));
70 2 : ACL_LOG_INFO("successfully execute aclrtSetCurrentContext");
71 2 : return ACL_SUCCESS;
72 6 : }
73 :
74 6 : aclError aclrtGetCurrentContextImpl(aclrtContext* context)
75 : {
76 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetCurrentContext);
77 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(context);
78 :
79 4 : rtContext_t rtCtx = nullptr;
80 4 : const rtError_t rtErr = rtCtxGetCurrent(&rtCtx);
81 4 : if (rtErr != RT_ERROR_NONE) {
82 2 : ACL_LOG_INFO("Cannot get current context, runtime errorCode is %d", static_cast<int32_t>(rtErr));
83 2 : return ACL_GET_ERRCODE_RTS(rtErr);
84 : }
85 :
86 2 : *context = rtCtx;
87 2 : return ACL_SUCCESS;
88 6 : }
89 :
90 10 : static aclError GetSysParamOpt(aclSysParamOpt opt, int64_t* value, bool isCtx)
91 : {
92 10 : constexpr aclSysParamOpt OPT_STRONG_CONSISTENCY = static_cast<aclSysParamOpt>(2);
93 10 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT_AND_FUNC_DESC(
94 : value, "Obtaining system parameter values from the current context");
95 8 : rtError_t rtErr = RT_ERROR_NONE;
96 8 : if (isCtx) {
97 7 : ACL_CHECK_INVALID_VALUE_WITH_DESC_AND_FUNC_DESC(
98 : (opt == ACL_OPT_DETERMINISTIC || opt == ACL_OPT_ENABLE_DEBUG_KERNEL || opt == OPT_STRONG_CONSISTENCY),
99 : acl::GetSysParamOptDesc(opt), "opt",
100 : "ACL_OPT_DETERMINISTIC(0) or ACL_OPT_ENABLE_DEBUG_KERNEL(1) or ACL_OPT_STRONG_CONSISTENCY(2)",
101 : ACL_ERROR_INVALID_PARAM, "Obtaining system parameter values from the current context");
102 3 : rtErr = rtCtxGetSysParamOpt(static_cast<rtSysParamOpt>(opt), value);
103 : } else {
104 7 : ACL_CHECK_INVALID_VALUE_WITH_DESC_AND_FUNC_DESC(
105 : (opt == ACL_OPT_DETERMINISTIC || opt == ACL_OPT_ENABLE_DEBUG_KERNEL || opt == OPT_STRONG_CONSISTENCY ||
106 : opt == ACL_OPT_ENABLE_KERNEL_EARLY_START),
107 : acl::GetSysParamOptDesc(opt), "opt",
108 : "ACL_OPT_DETERMINISTIC(0) or ACL_OPT_ENABLE_DEBUG_KERNEL(1) or ACL_OPT_STRONG_CONSISTENCY(2) or "
109 : "ACL_OPT_ENABLE_KERNEL_EARLY_START(3)",
110 : ACL_ERROR_INVALID_PARAM, "Obtaining system parameter values from the current context");
111 3 : rtErr = rtGetSysParamOpt(static_cast<rtSysParamOpt>(opt), value);
112 : }
113 :
114 6 : if (rtErr != RT_ERROR_NONE) {
115 4 : if (rtErr == ACL_ERROR_RT_SYSPARAMOPT_NOT_SET) {
116 2 : ACL_LOG_WARN(
117 : "option %s is not set, runtime errorCode is %d", acl::GetSysParamOptDesc(opt),
118 : static_cast<int32_t>(rtErr));
119 : }
120 4 : return ACL_GET_ERRCODE_RTS(rtErr);
121 : }
122 2 : return ACL_SUCCESS;
123 : }
124 :
125 25 : static aclError SetSysParamOpt(aclSysParamOpt opt, int64_t value, bool isCtx)
126 : {
127 25 : constexpr aclSysParamOpt OPT_STRONG_CONSISTENCY = static_cast<aclSysParamOpt>(2);
128 25 : if (isCtx) {
129 21 : ACL_CHECK_INVALID_VALUE_WITH_DESC_AND_FUNC_DESC(
130 : (opt == ACL_OPT_DETERMINISTIC || opt == ACL_OPT_ENABLE_DEBUG_KERNEL || opt == OPT_STRONG_CONSISTENCY),
131 : acl::GetSysParamOptDesc(opt), "opt",
132 : "ACL_OPT_DETERMINISTIC(0) or ACL_OPT_ENABLE_DEBUG_KERNEL(1) or ACL_OPT_STRONG_CONSISTENCY(2)",
133 : ACL_ERROR_INVALID_PARAM, "Setting system parameter values in the current context");
134 9 : ACL_REQUIRES_RTS_OK(rtCtxSetSysParamOpt(static_cast<rtSysParamOpt>(opt), value));
135 8 : ACL_LOG_INFO("successfully execute aclrtCtxSetSysParamOpt");
136 : } else {
137 22 : ACL_CHECK_INVALID_VALUE_WITH_DESC_AND_FUNC_DESC(
138 : (opt == ACL_OPT_DETERMINISTIC || opt == ACL_OPT_ENABLE_DEBUG_KERNEL || opt == OPT_STRONG_CONSISTENCY ||
139 : opt == ACL_OPT_ENABLE_KERNEL_EARLY_START),
140 : acl::GetSysParamOptDesc(opt), "opt",
141 : "ACL_OPT_DETERMINISTIC(0) or ACL_OPT_ENABLE_DEBUG_KERNEL(1) or ACL_OPT_STRONG_CONSISTENCY(2) or "
142 : "ACL_OPT_ENABLE_KERNEL_EARLY_START(3)",
143 : ACL_ERROR_INVALID_PARAM, "Setting system parameter values in the current context");
144 10 : ACL_REQUIRES_RTS_OK(rtSetSysParamOpt(static_cast<rtSysParamOpt>(opt), value));
145 9 : ACL_LOG_INFO("successfully execute aclrtSetSysParamOpt");
146 : }
147 17 : return ACL_SUCCESS;
148 : }
149 :
150 5 : aclError aclrtCtxGetSysParamOptImpl(aclSysParamOpt opt, int64_t* value)
151 : {
152 5 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetSysParamOpt);
153 10 : return GetSysParamOpt(opt, value, true);
154 5 : }
155 :
156 12 : aclError aclrtCtxSetSysParamOptImpl(aclSysParamOpt opt, int64_t value)
157 : {
158 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxSetSysParamOpt);
159 12 : ACL_LOG_INFO(
160 : "start to execute aclrtCtxSetSysParamOpt, opt = %s, value = %ld.", acl::GetSysParamOptDesc(opt), value);
161 24 : return SetSysParamOpt(opt, value, true);
162 12 : }
163 :
164 5 : aclError aclrtGetSysParamOptImpl(aclSysParamOpt opt, int64_t* value) { return GetSysParamOpt(opt, value, false); }
165 :
166 13 : aclError aclrtSetSysParamOptImpl(aclSysParamOpt opt, int64_t value)
167 : {
168 13 : ACL_LOG_INFO("start to execute aclrtSetSysParamOpt, opt = %s, value = %ld.", acl::GetSysParamOptDesc(opt), value);
169 13 : return SetSysParamOpt(opt, value, false);
170 : }
171 :
172 2 : aclError aclrtPeekAtLastErrorImpl(aclrtLastErrLevel level)
173 : {
174 2 : ACL_LOG_INFO("start to execute aclrtPeekAtLastError, level is %s", acl::GetLastErrLevelDesc(level));
175 5 : ACL_REQUIRES_PARAM_EQUAL_REPORT(level, ACL_RT_THREAD_LEVEL);
176 1 : const rtLastErrLevel_t rtLevel = static_cast<rtLastErrLevel_t>(level);
177 1 : return rtPeekAtLastError(rtLevel);
178 : }
179 :
180 2 : aclError aclrtGetLastErrorImpl(aclrtLastErrLevel level)
181 : {
182 2 : ACL_LOG_INFO("start to execute aclrtGetLastError, level is %s", acl::GetLastErrLevelDesc(level));
183 5 : ACL_REQUIRES_PARAM_EQUAL_REPORT(level, ACL_RT_THREAD_LEVEL);
184 1 : const rtLastErrLevel_t rtLevel = static_cast<rtLastErrLevel_t>(level);
185 1 : return rtGetLastError(rtLevel);
186 : }
187 :
188 3 : aclError aclrtCtxGetCurrentDefaultStreamImpl(aclrtStream* stream)
189 : {
190 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetCurrentDefaultStream);
191 3 : ACL_LOG_INFO("start to execute aclrtCtxGetCurrentDefaultStream");
192 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
193 :
194 2 : const rtError_t rtErr = rtsCtxGetCurrentDefaultStream(stream);
195 2 : if (rtErr != RT_ERROR_NONE) {
196 1 : ACL_LOG_ERROR(
197 : "call rtsCtxGetCurrentDefaultStream failed, runtime errorCode is %d", static_cast<int32_t>(rtErr));
198 1 : return ACL_GET_ERRCODE_RTS(rtErr);
199 : }
200 :
201 1 : ACL_LOG_INFO("successfully execute aclrtCtxGetCurrentDefaultStream");
202 1 : return ACL_SUCCESS;
203 3 : }
204 :
205 2 : aclError aclrtCtxGetFloatOverflowAddrImpl(void** overflowAddr)
206 : {
207 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetFloatOverflowAddr);
208 :
209 2 : const rtError_t rtErr = rtsCtxGetFloatOverflowAddr(overflowAddr);
210 2 : if (rtErr != RT_ERROR_NONE) {
211 1 : ACL_LOG_ERROR("call rtsCtxGetFloatOverflowAddr failed, runtime errorCode is %d", static_cast<int32_t>(rtErr));
212 1 : return ACL_GET_ERRCODE_RTS(rtErr);
213 : }
214 :
215 1 : return ACL_SUCCESS;
216 2 : }
217 :
218 4 : aclError aclrtGetPrimaryCtxStateImpl(int32_t deviceId, uint32_t* flags, int32_t* active)
219 : {
220 4 : ACL_LOG_INFO("start to execute aclrtGetPrimaryCtxState");
221 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(active);
222 3 : ACL_CHECK_INVALID_PARAM_NO_VALUE(flags == nullptr, "flags", "flags is a reserved parameter and must be nullptr");
223 :
224 2 : uint32_t tmp = 0;
225 2 : const rtError_t rtErr = rtsGetPrimaryCtxState(deviceId, &tmp, active);
226 2 : if (rtErr != RT_ERROR_NONE) {
227 1 : ACL_LOG_WARN(
228 : "call aclrtGetPrimaryCtxState failed, runtime errorCode is %d, device id is %d",
229 : static_cast<int32_t>(rtErr), deviceId);
230 1 : return ACL_GET_ERRCODE_RTS(rtErr);
231 : }
232 1 : ACL_LOG_INFO("successfully execute aclrtGetPrimaryCtxState");
233 1 : return ACL_SUCCESS;
234 : }
235 : #ifdef __cplusplus
236 : }
237 : #endif
|
