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