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 14 : ACL_CHECK_INVALID_VALUE_WITH_DESC_AND_FUNC_DESC(
96 : (opt == ACL_OPT_DETERMINISTIC || opt == ACL_OPT_ENABLE_DEBUG_KERNEL || opt == OPT_STRONG_CONSISTENCY),
97 : acl::GetSysParamOptDesc(opt), "opt",
98 : "ACL_OPT_DETERMINISTIC(0) or ACL_OPT_ENABLE_DEBUG_KERNEL(1) or ACL_OPT_STRONG_CONSISTENCY(2)",
99 : ACL_ERROR_INVALID_PARAM, "Obtaining system parameter values from the current context");
100 6 : rtError_t rtErr = RT_ERROR_NONE;
101 6 : if (isCtx) {
102 3 : rtErr = rtCtxGetSysParamOpt(static_cast<rtSysParamOpt>(opt), value);
103 : } else {
104 3 : rtErr = rtGetSysParamOpt(static_cast<rtSysParamOpt>(opt), value);
105 : }
106 :
107 6 : if (rtErr != RT_ERROR_NONE) {
108 4 : if (rtErr == ACL_ERROR_RT_SYSPARAMOPT_NOT_SET) {
109 2 : ACL_LOG_WARN(
110 : "option %d is not set, runtime errorCode is %d", static_cast<int32_t>(opt),
111 : static_cast<int32_t>(rtErr));
112 : }
113 4 : return ACL_GET_ERRCODE_RTS(rtErr);
114 : }
115 2 : return ACL_SUCCESS;
116 : }
117 :
118 24 : static aclError SetSysParamOpt(aclSysParamOpt opt, int64_t value, bool isCtx)
119 : {
120 24 : constexpr aclSysParamOpt OPT_STRONG_CONSISTENCY = static_cast<aclSysParamOpt>(2);
121 42 : ACL_CHECK_INVALID_VALUE_WITH_DESC_AND_FUNC_DESC(
122 : (opt == ACL_OPT_DETERMINISTIC || opt == ACL_OPT_ENABLE_DEBUG_KERNEL || opt == OPT_STRONG_CONSISTENCY),
123 : acl::GetSysParamOptDesc(opt), "opt",
124 : "ACL_OPT_DETERMINISTIC(0) or ACL_OPT_ENABLE_DEBUG_KERNEL(1) or ACL_OPT_STRONG_CONSISTENCY(2)",
125 : ACL_ERROR_INVALID_PARAM, "Setting system parameter values in the current context");
126 18 : if (isCtx) {
127 9 : ACL_REQUIRES_RTS_OK(rtCtxSetSysParamOpt(static_cast<rtSysParamOpt>(opt), value));
128 : } else {
129 9 : ACL_REQUIRES_RTS_OK(rtSetSysParamOpt(static_cast<rtSysParamOpt>(opt), value));
130 : }
131 16 : ACL_LOG_INFO("successfully execute aclrtCtxSetSysParamOpt");
132 16 : return ACL_SUCCESS;
133 : }
134 :
135 5 : aclError aclrtCtxGetSysParamOptImpl(aclSysParamOpt opt, int64_t* value)
136 : {
137 5 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetSysParamOpt);
138 10 : return GetSysParamOpt(opt, value, true);
139 5 : }
140 :
141 12 : aclError aclrtCtxSetSysParamOptImpl(aclSysParamOpt opt, int64_t value)
142 : {
143 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxSetSysParamOpt);
144 12 : ACL_LOG_INFO("start to execute aclrtCtxSetSysParamOpt, opt = %d, value = %ld.", static_cast<int32_t>(opt), value);
145 24 : return SetSysParamOpt(opt, value, true);
146 12 : }
147 :
148 5 : aclError aclrtGetSysParamOptImpl(aclSysParamOpt opt, int64_t* value) { return GetSysParamOpt(opt, value, false); }
149 :
150 12 : aclError aclrtSetSysParamOptImpl(aclSysParamOpt opt, int64_t value)
151 : {
152 12 : ACL_LOG_INFO("start to execute aclrtSetSysParamOpt, opt = %d, value = %ld.", static_cast<int32_t>(opt), value);
153 12 : return SetSysParamOpt(opt, value, false);
154 : }
155 :
156 2 : aclError aclrtPeekAtLastErrorImpl(aclrtLastErrLevel level)
157 : {
158 2 : ACL_LOG_INFO("start to execute aclrtPeekAtLastError, level is %d", static_cast<int32_t>(level));
159 5 : ACL_REQUIRES_PARAM_EQUAL_REPORT(level, ACL_RT_THREAD_LEVEL);
160 1 : const rtLastErrLevel_t rtLevel = static_cast<rtLastErrLevel_t>(level);
161 1 : return rtPeekAtLastError(rtLevel);
162 : }
163 :
164 2 : aclError aclrtGetLastErrorImpl(aclrtLastErrLevel level)
165 : {
166 2 : ACL_LOG_INFO("start to execute aclrtGetLastError, level is %d", static_cast<int32_t>(level));
167 5 : ACL_REQUIRES_PARAM_EQUAL_REPORT(level, ACL_RT_THREAD_LEVEL);
168 1 : const rtLastErrLevel_t rtLevel = static_cast<rtLastErrLevel_t>(level);
169 1 : return rtGetLastError(rtLevel);
170 : }
171 :
172 3 : aclError aclrtCtxGetCurrentDefaultStreamImpl(aclrtStream* stream)
173 : {
174 3 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetCurrentDefaultStream);
175 3 : ACL_LOG_INFO("start to execute aclrtCtxGetCurrentDefaultStream");
176 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(stream);
177 :
178 2 : const rtError_t rtErr = rtsCtxGetCurrentDefaultStream(stream);
179 2 : if (rtErr != RT_ERROR_NONE) {
180 1 : ACL_LOG_ERROR(
181 : "call rtsCtxGetCurrentDefaultStream failed, runtime errorCode is %d", static_cast<int32_t>(rtErr));
182 1 : return ACL_GET_ERRCODE_RTS(rtErr);
183 : }
184 :
185 1 : ACL_LOG_INFO("successfully execute aclrtCtxGetCurrentDefaultStream");
186 1 : return ACL_SUCCESS;
187 3 : }
188 :
189 2 : aclError aclrtCtxGetFloatOverflowAddrImpl(void** overflowAddr)
190 : {
191 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtCtxGetFloatOverflowAddr);
192 :
193 2 : const rtError_t rtErr = rtsCtxGetFloatOverflowAddr(overflowAddr);
194 2 : if (rtErr != RT_ERROR_NONE) {
195 1 : ACL_LOG_ERROR("call rtsCtxGetFloatOverflowAddr failed, runtime errorCode is %d", static_cast<int32_t>(rtErr));
196 1 : return ACL_GET_ERRCODE_RTS(rtErr);
197 : }
198 :
199 1 : return ACL_SUCCESS;
200 2 : }
201 :
202 4 : aclError aclrtGetPrimaryCtxStateImpl(int32_t deviceId, uint32_t* flags, int32_t* active)
203 : {
204 4 : ACL_LOG_INFO("start to execute aclrtGetPrimaryCtxState");
205 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(active);
206 3 : ACL_CHECK_INVALID_PARAM_NO_VALUE(flags == nullptr, "flags", "flags is a reserved parameter and must be nullptr");
207 :
208 2 : uint32_t tmp = 0;
209 2 : const rtError_t rtErr = rtsGetPrimaryCtxState(deviceId, &tmp, active);
210 2 : if (rtErr != RT_ERROR_NONE) {
211 1 : ACL_LOG_WARN(
212 : "call aclrtGetPrimaryCtxState failed, runtime errorCode is %d, device id is %d",
213 : static_cast<int32_t>(rtErr), deviceId);
214 1 : return ACL_GET_ERRCODE_RTS(rtErr);
215 : }
216 1 : ACL_LOG_INFO("successfully execute aclrtGetPrimaryCtxState");
217 1 : return ACL_SUCCESS;
218 : }
219 : #ifdef __cplusplus
220 : }
221 : #endif
|
