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 <map>
12 : #include <algorithm>
13 : #include <functional>
14 : #include "acl_rt_impl.h"
15 : #include "runtime/mem.h"
16 : #include "runtime/rts/rts_mem.h"
17 : #include "runtime/dev.h"
18 : #include "runtime/rts/rts_device.h"
19 : #include "runtime/rt_stars.h"
20 : #include "runtime/rt_mem_queue.h"
21 : #include "runtime/rt_inner_mem.h"
22 : #include "common/log_inner.h"
23 : #include "common/error_codes_inner.h"
24 : #include "common/prof_reporter.h"
25 : #include "common/resource_statistics.h"
26 :
27 : namespace {
28 : constexpr uint32_t MEM_SIZE_MAX = 96U;
29 : constexpr size_t DATA_MEMORY_ALIGN_SIZE = 32UL;
30 : constexpr unsigned int FLAG_START_DYNAMIC_ALLOC_MEM = 0x200U;
31 : constexpr uint32_t DRV_MEM_HOST_NUMA_SIDE = 2U;
32 :
33 : static const std::map<aclDataType, rtDataType> kMapDataType = {
34 : { ACL_FLOAT, RT_DATA_TYPE_FP32 },
35 : { ACL_FLOAT16, RT_DATA_TYPE_FP16 },
36 : { ACL_INT16, RT_DATA_TYPE_INT16 },
37 : { ACL_INT4, RT_DATA_TYPE_INT4 },
38 : { ACL_INT8, RT_DATA_TYPE_INT8 },
39 : { ACL_INT32, RT_DATA_TYPE_INT32 },
40 : { ACL_BF16, RT_DATA_TYPE_BFP16 },
41 : { ACL_UINT8, RT_DATA_TYPE_UINT8 },
42 : { ACL_UINT16, RT_DATA_TYPE_UINT16 },
43 : { ACL_UINT32, RT_DATA_TYPE_UINT32 },
44 : };
45 :
46 : using Handler = std::function<void(rtDrvMemProp_t&, bool, bool)>;
47 : static const std::map<int32_t, Handler> memAttrHandlers = {
48 : // HBM (Direct Assign)
49 7 : {ACL_HBM_MEM_HUGE, [](rtDrvMemProp_t& p, bool, bool) { p.pg_type = HUGE_PAGE_TYPE; p.mem_type = HBM_TYPE; }},
50 4 : {ACL_HBM_MEM_NORMAL, [](rtDrvMemProp_t& p, bool, bool) { p.pg_type = NORMAL_PAGE_TYPE; p.mem_type = HBM_TYPE; }},
51 3 : {ACL_HBM_MEM_HUGE1G, [](rtDrvMemProp_t& p, bool, bool) { p.pg_type = HUGE1G_PAGE_TYPE; p.mem_type = HBM_TYPE; }},
52 :
53 : // DDR (Host Only)
54 1 : {ACL_DDR_MEM_HUGE, [](rtDrvMemProp_t& p, bool isHost, bool) { if(isHost) { p.pg_type = HUGE_PAGE_TYPE; p.mem_type = DDR_TYPE; } }},
55 1 : {ACL_DDR_MEM_NORMAL, [](rtDrvMemProp_t& p, bool isHost, bool) { if(isHost) { p.pg_type = NORMAL_PAGE_TYPE; p.mem_type = DDR_TYPE; } }},
56 1 : {ACL_DDR_MEM_P2P_HUGE, [](rtDrvMemProp_t& p, bool isHost, bool) { if(isHost) { p.pg_type = HUGE_PAGE_TYPE; p.mem_type = P2P_DDR_TYPE; } }},
57 1 : {ACL_DDR_MEM_P2P_NORMAL, [](rtDrvMemProp_t& p, bool isHost, bool) { if(isHost) { p.pg_type = NORMAL_PAGE_TYPE; p.mem_type = P2P_DDR_TYPE; } }},
58 :
59 : // Generic (Host / Device)
60 2 : {ACL_MEM_NORMAL, [](rtDrvMemProp_t& p, bool isHost, bool isDev) { if(isHost) { p.pg_type = NORMAL_PAGE_TYPE; p.mem_type = DDR_TYPE; } else if(isDev) { p.pg_type = NORMAL_PAGE_TYPE; p.mem_type = HBM_TYPE; } }},
61 2 : {ACL_MEM_HUGE, [](rtDrvMemProp_t& p, bool isHost, bool isDev) { if(isHost) { p.pg_type = HUGE_PAGE_TYPE; p.mem_type = DDR_TYPE; } else if(isDev) { p.pg_type = HUGE_PAGE_TYPE; p.mem_type = HBM_TYPE; } }},
62 2 : {ACL_MEM_HUGE1G, [](rtDrvMemProp_t& p, bool isHost, bool isDev) { if(isHost) { p.pg_type = HUGE1G_PAGE_TYPE; p.mem_type = DDR_TYPE; } else if(isDev) { p.pg_type = HUGE1G_PAGE_TYPE; p.mem_type = HBM_TYPE; } }},
63 :
64 : // P2P (Host / Device)
65 2 : {ACL_MEM_P2P_NORMAL, [](rtDrvMemProp_t& p, bool isHost, bool isDev) { if(isHost) { p.pg_type = NORMAL_PAGE_TYPE; p.mem_type = P2P_DDR_TYPE; } else if(isDev) { p.pg_type = NORMAL_PAGE_TYPE; p.mem_type = P2P_HBM_TYPE; } }},
66 2 : {ACL_MEM_P2P_HUGE, [](rtDrvMemProp_t& p, bool isHost, bool isDev) { if(isHost) { p.pg_type = HUGE_PAGE_TYPE; p.mem_type = P2P_DDR_TYPE; } else if(isDev) { p.pg_type = HUGE_PAGE_TYPE; p.mem_type = P2P_HBM_TYPE; } }},
67 2 : {ACL_MEM_P2P_HUGE1G, [](rtDrvMemProp_t& p, bool isHost, bool isDev) { if(isHost) { p.pg_type = HUGE1G_PAGE_TYPE; p.mem_type = P2P_DDR_TYPE; } else if(isDev) { p.pg_type = HUGE1G_PAGE_TYPE; p.mem_type = P2P_HBM_TYPE; } }}
68 : };
69 :
70 34 : inline aclError MemcpyKindTranslate(const aclrtMemcpyKind kind, rtMemcpyKind_t &rtKind)
71 : {
72 34 : switch (kind) {
73 7 : case ACL_MEMCPY_HOST_TO_DEVICE: {
74 7 : rtKind = RT_MEMCPY_HOST_TO_DEVICE;
75 7 : break;
76 : }
77 7 : case ACL_MEMCPY_DEVICE_TO_DEVICE: {
78 7 : rtKind = RT_MEMCPY_DEVICE_TO_DEVICE;
79 7 : break;
80 : }
81 4 : case ACL_MEMCPY_DEVICE_TO_HOST: {
82 4 : rtKind = RT_MEMCPY_DEVICE_TO_HOST;
83 4 : break;
84 : }
85 4 : case ACL_MEMCPY_HOST_TO_HOST: {
86 4 : rtKind = RT_MEMCPY_HOST_TO_HOST;
87 4 : break;
88 : }
89 4 : case ACL_MEMCPY_DEFAULT: {
90 4 : rtKind = RT_MEMCPY_DEFAULT;
91 4 : break;
92 : }
93 4 : case ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE: {
94 4 : rtKind = RT_MEMCPY_HOST_TO_DEVICE_EX;
95 4 : break;
96 : }
97 4 : default: {
98 4 : ACL_LOG_ERROR("[Check][MemcpyKindTranslate]param kind invalid, which is %d.", static_cast<int32_t>(kind));
99 12 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
100 8 : std::vector<const char *>({"param", "value", "reason"}),
101 8 : std::vector<const char *>({"kind", std::to_string(kind).c_str(),
102 : "Memcpy kind should be ACL_MEMCPY_HOST_TO_DEVICE,"
103 : "ACL_MEMCPY_DEVICE_TO_DEVICE, ACL_MEMCPY_DEVICE_TO_HOST,"
104 : "ACL_MEMCPY_HOST_TO_HOST, ACL_MEMCPY_DEFAULT or ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE."}));
105 4 : return ACL_ERROR_INVALID_PARAM;
106 : }
107 : }
108 30 : return ACL_SUCCESS;
109 : }
110 :
111 15 : aclError CheckMemcpy2dParam(const void *const dst, const size_t dpitch, const void *const src, const size_t spitch,
112 : const size_t width, const size_t height, const aclrtMemcpyKind kind, rtMemcpyKind_t &rtKind)
113 : {
114 15 : ACL_LOG_DEBUG("start to execute CheckMemcpy2dParam");
115 15 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(dst);
116 15 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(src);
117 15 : ACL_REQUIRES_POSITIVE(height);
118 13 : ACL_REQUIRES_POSITIVE(width);
119 :
120 13 : if ((width > spitch) || (width > dpitch)) {
121 2 : ACL_LOG_ERROR("[Check][Width]input param width[%zu] must be smaller than spitch[%zu] and dpitch[%zu]",
122 : width, spitch, dpitch);
123 6 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
124 4 : std::vector<const char *>({"param", "value", "reason"}),
125 4 : std::vector<const char *>({"width", std::to_string(width).c_str(), "must be smaller than spitch and dpitch"}));
126 2 : return ACL_ERROR_INVALID_PARAM;
127 : }
128 :
129 11 : switch (kind) {
130 4 : case ACL_MEMCPY_HOST_TO_DEVICE: {
131 4 : rtKind = RT_MEMCPY_HOST_TO_DEVICE;
132 4 : break;
133 : }
134 0 : case ACL_MEMCPY_DEVICE_TO_HOST: {
135 0 : rtKind = RT_MEMCPY_DEVICE_TO_HOST;
136 0 : break;
137 : }
138 1 : case ACL_MEMCPY_DEVICE_TO_DEVICE: {
139 1 : rtKind = RT_MEMCPY_DEVICE_TO_DEVICE;
140 1 : break;
141 : }
142 2 : case ACL_MEMCPY_DEFAULT: {
143 2 : rtKind = RT_MEMCPY_DEFAULT;
144 2 : break;
145 : }
146 4 : default: {
147 4 : ACL_LOG_ERROR("[Check][Kind]invalid kind of memcpy, kind = %d", static_cast<int32_t>(kind));
148 12 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
149 8 : std::vector<const char *>({"param", "value", "reason"}),
150 8 : std::vector<const char *>({"kind", std::to_string(kind).c_str(), "invalid kind of memcpy"}));
151 4 : return ACL_ERROR_INVALID_PARAM;
152 : }
153 : }
154 7 : return ACL_SUCCESS;
155 : }
156 : }
157 :
158 : namespace acl {
159 53 : aclError GetAlignedAndPaddingSize(const size_t size, const bool isPadding, size_t &alignedSize)
160 : {
161 : // check overflow, the max value of size must be less than 0xFFFFFFFFFFFFFFFF-32*2
162 53 : if ((size + (DATA_MEMORY_ALIGN_SIZE * 2UL)) < size) {
163 7 : ACL_LOG_INNER_ERROR("[Check][Size]size too large: %zu", size);
164 7 : return ACL_ERROR_INVALID_PARAM;
165 : }
166 :
167 : // align size to multiple of 32 and padding 32 if needed
168 46 : const size_t appendSize = isPadding ? DATA_MEMORY_ALIGN_SIZE * 2UL : DATA_MEMORY_ALIGN_SIZE;
169 46 : alignedSize = (size + appendSize - 1UL) / DATA_MEMORY_ALIGN_SIZE * DATA_MEMORY_ALIGN_SIZE;
170 46 : return ACL_SUCCESS;
171 : }
172 :
173 42 : aclError aclMallocMemInner(void **devPtr, const size_t size, bool isPadding,
174 : const aclrtMemMallocPolicy policy, const uint16_t moduleId)
175 : {
176 42 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
177 42 : ACL_LOG_DEBUG("start to execute aclMallocMemInner, size = %zu", size);
178 42 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
179 : // size must be greater than zero
180 39 : if (size == 0UL) {
181 3 : ACL_LOG_ERROR("malloc size must be greater than zero");
182 9 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
183 6 : std::vector<const char *>({"param", "value", "reason"}),
184 6 : std::vector<const char *>({"size", std::to_string(size).c_str(), "size must be greater than zero"}));
185 3 : return ACL_ERROR_INVALID_PARAM;
186 : }
187 36 : size_t alignedSize = size;
188 36 : const bool huge1g = (policy == ACL_MEM_MALLOC_HUGE1G_ONLY) || (policy == ACL_MEM_MALLOC_HUGE1G_ONLY_P2P);
189 36 : isPadding = !huge1g && isPadding;
190 36 : ACL_REQUIRES_OK(acl::GetAlignedAndPaddingSize(size, isPadding, alignedSize));
191 33 : uint32_t flags = RT_MEMORY_DEFAULT;
192 33 : if (policy == ACL_MEM_MALLOC_HUGE_FIRST) {
193 9 : flags |= RT_MEMORY_POLICY_HUGE_PAGE_FIRST;
194 24 : } else if (policy == ACL_MEM_MALLOC_HUGE_ONLY) {
195 4 : flags |= RT_MEMORY_POLICY_HUGE_PAGE_ONLY;
196 20 : } else if (policy == ACL_MEM_MALLOC_NORMAL_ONLY) {
197 3 : flags |= RT_MEMORY_POLICY_DEFAULT_PAGE_ONLY;
198 17 : } else if (policy == ACL_MEM_MALLOC_HUGE_FIRST_P2P) {
199 3 : flags |= RT_MEMORY_POLICY_HUGE_PAGE_FIRST_P2P;
200 14 : } else if (policy == ACL_MEM_MALLOC_HUGE_ONLY_P2P) {
201 7 : flags |= RT_MEMORY_POLICY_HUGE_PAGE_ONLY_P2P;
202 7 : } else if (policy == ACL_MEM_MALLOC_NORMAL_ONLY_P2P) {
203 3 : flags |= RT_MEMORY_POLICY_DEFAULT_PAGE_ONLY_P2P;
204 4 : } else if (policy == ACL_MEM_MALLOC_HUGE1G_ONLY) {
205 2 : flags |= RT_MEMORY_POLICY_HUGE1G_PAGE_ONLY;
206 2 : } else if (policy == ACL_MEM_MALLOC_HUGE1G_ONLY_P2P) {
207 2 : flags |= RT_MEMORY_POLICY_HUGE1G_PAGE_ONLY_P2P;
208 : } else {
209 0 : flags = RT_MEMORY_DEFAULT;
210 : }
211 33 : const rtError_t rtErr = rtMalloc(devPtr, alignedSize, flags, moduleId);
212 33 : if (rtErr != RT_ERROR_NONE) {
213 3 : ACL_LOG_CALL_ERROR("alloc device memory failed, runtime result = %d", rtErr);
214 3 : return ACL_GET_ERRCODE_RTS(rtErr);
215 : }
216 30 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
217 30 : return ACL_SUCCESS;
218 : }
219 :
220 10 : aclError aclrtMallocInnerWithCfg(void **devPtr, const size_t size, aclrtMemMallocPolicy policy, rtMallocAdvise advise,
221 : aclrtMallocConfig *cfg)
222 : {
223 10 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
224 10 : ACL_LOG_DEBUG("start to execute aclrtMallocInnerWithCfg, size = %zu", size);
225 10 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
226 :
227 : // check attrs pointer
228 9 : if ((cfg != nullptr) && (cfg->numAttrs != 0) && (cfg->attrs == nullptr)) {
229 1 : ACL_LOG_ERROR("[Check][attrs]param must not be null when numAttrs is not 0.");
230 1 : acl::AclErrorLogManager::ReportInputError("EH0002", {"param"}, {"cfg"});
231 1 : return ACL_ERROR_INVALID_PARAM;
232 : }
233 : // size must be greater than zero
234 8 : if (size == 0UL) {
235 1 : ACL_LOG_ERROR("malloc size must be greater than zero");
236 3 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
237 2 : std::vector<const char *>({"param", "value", "reason"}),
238 2 : std::vector<const char *>({"size", std::to_string(size).c_str(), "size must be greater than zero"}));
239 1 : return ACL_ERROR_INVALID_PARAM;
240 : }
241 :
242 7 : rtError_t rtErr = rtsMalloc(devPtr, size, static_cast<rtMallocPolicy>(policy), advise,
243 : reinterpret_cast<rtMallocConfig_t*>(cfg));
244 7 : if (rtErr != RT_ERROR_NONE) {
245 2 : ACL_LOG_CALL_ERROR("alloc memory failed, runtime result = %d", rtErr);
246 2 : return ACL_GET_ERRCODE_RTS(rtErr);
247 : }
248 5 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
249 5 : return ACL_SUCCESS;
250 : }
251 : } // namespace acl
252 :
253 30 : aclError aclrtMallocImpl(void **devPtr, size_t size, aclrtMemMallocPolicy policy)
254 : {
255 60 : ACL_PROFILING_REG(acl::AclProfType::AclrtMalloc);
256 30 : ACL_LOG_DEBUG("start to execute aclrtMalloc, size = %zu", size);
257 60 : return acl::aclMallocMemInner(devPtr, size, true, policy, acl::APP_MODE_ID_U16);
258 : }
259 :
260 12 : aclError aclrtMallocAlign32Impl(void **devPtr, size_t size, aclrtMemMallocPolicy policy)
261 : {
262 12 : ACL_LOG_DEBUG("start to execute aclrtMallocAlign32, size = %zu", size);
263 12 : return acl::aclMallocMemInner(devPtr, size, false, policy, acl::APP_MODE_ID_U16);
264 : }
265 :
266 11 : aclError aclrtMallocCachedImpl(void **devPtr, size_t size, aclrtMemMallocPolicy policy)
267 : {
268 22 : ACL_PROFILING_REG(acl::AclProfType::AclrtMallocCached);
269 11 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
270 11 : ACL_LOG_DEBUG("start to execute aclrtMallocCached, size = %zu", size);
271 11 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
272 :
273 11 : if (size == 0UL) {
274 2 : ACL_LOG_INNER_ERROR("malloc size must be greater than zero");
275 2 : return ACL_ERROR_INVALID_PARAM;
276 : }
277 9 : size_t alignedSize = size;
278 9 : const bool huge1g = (policy == ACL_MEM_MALLOC_HUGE1G_ONLY) || (policy == ACL_MEM_MALLOC_HUGE1G_ONLY_P2P);
279 9 : const bool isPadding = !huge1g;
280 9 : ACL_REQUIRES_OK(acl::GetAlignedAndPaddingSize(size, isPadding, alignedSize));
281 7 : uint32_t cacheFlags = RT_MEMORY_DEFAULT;
282 7 : if (policy == ACL_MEM_MALLOC_HUGE_FIRST) {
283 3 : cacheFlags |= RT_MEMORY_POLICY_HUGE_PAGE_FIRST;
284 4 : } else if (policy == ACL_MEM_MALLOC_HUGE_ONLY) {
285 2 : cacheFlags |= RT_MEMORY_POLICY_HUGE_PAGE_ONLY;
286 2 : } else if (policy == ACL_MEM_MALLOC_NORMAL_ONLY) {
287 1 : cacheFlags |= RT_MEMORY_POLICY_DEFAULT_PAGE_ONLY;
288 1 : } else if (policy == ACL_MEM_MALLOC_HUGE1G_ONLY) {
289 1 : cacheFlags |= RT_MEMORY_POLICY_HUGE1G_PAGE_ONLY;
290 : } else {
291 0 : cacheFlags = RT_MEMORY_DEFAULT;
292 : }
293 7 : const rtError_t rtErr = rtMallocCached(devPtr, alignedSize, cacheFlags, acl::APP_MODE_ID_U16);
294 7 : if (rtErr != RT_ERROR_NONE) {
295 2 : ACL_LOG_CALL_ERROR("alloc device memory with cache failed, runtime result = %d", static_cast<int32_t>(rtErr));
296 2 : return ACL_GET_ERRCODE_RTS(rtErr);
297 : }
298 5 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
299 5 : return ACL_SUCCESS;
300 : }
301 :
302 7 : aclError aclrtMallocWithCfgImpl(void **devPtr, size_t size, aclrtMemMallocPolicy policy, aclrtMallocConfig *cfg)
303 : {
304 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtMallocWithCfg);
305 7 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
306 7 : ACL_LOG_DEBUG("start to execute aclrtMallocWithCfg, size = %zu", size);
307 14 : return acl::aclrtMallocInnerWithCfg(devPtr, size, policy, RT_MEM_ADVISE_NONE, cfg);
308 : }
309 :
310 3 : aclError aclrtMallocForTaskSchedulerImpl(void **devPtr, size_t size, aclrtMemMallocPolicy policy,
311 : aclrtMallocConfig *cfg)
312 : {
313 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtMallocForTaskScheduler);
314 3 : ACL_LOG_DEBUG("start to execute aclrtMallocForTaskScheduler, size = %zu", size);
315 6 : return acl::aclrtMallocInnerWithCfg(devPtr, size, policy, RT_MEM_ADVISE_TS, cfg);
316 : }
317 :
318 5 : aclError aclrtMallocHostWithCfgImpl(void **ptr, uint64_t size, aclrtMallocConfig *cfg)
319 : {
320 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtMallocHostWithCfg);
321 5 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
322 5 : ACL_LOG_DEBUG("start to execute aclrtMallocHostWithCfg, size = %zu", size);
323 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(ptr);
324 : // size must be greater than zero
325 4 : if (size == 0UL) {
326 1 : ACL_LOG_ERROR("malloc size must be greater than zero");
327 3 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
328 2 : std::vector<const char *>({"param", "value", "reason"}),
329 2 : std::vector<const char *>({"size", std::to_string(size).c_str(), "size must be greater than zero"}));
330 1 : return ACL_ERROR_INVALID_PARAM;
331 : }
332 3 : const rtError_t rtErr = rtsMallocHost(ptr, size, reinterpret_cast<rtMallocConfig_t*>(cfg));
333 3 : if (rtErr != RT_ERROR_NONE) {
334 1 : ACL_LOG_CALL_ERROR("alloc host memory with cfg failed, runtime result = %d", rtErr);
335 1 : return ACL_GET_ERRCODE_RTS(rtErr);
336 : }
337 2 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
338 2 : return ACL_SUCCESS;
339 : }
340 :
341 3 : aclError aclrtPointerGetAttributesImpl(const void *ptr, aclrtPtrAttributes *attributes)
342 : {
343 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtPointerGetAttributes);
344 3 : ACL_LOG_DEBUG("start to execute aclrtPointerGetAttributes");
345 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(ptr);
346 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(attributes);
347 2 : const rtError_t rtErr = rtsPointerGetAttributes(ptr, reinterpret_cast<rtPtrAttributes_t*>(attributes));
348 2 : if (rtErr != RT_ERROR_NONE) {
349 1 : ACL_LOG_CALL_ERROR("call rtsPointerGetAttributes failed, runtime result = %d", rtErr);
350 1 : return ACL_GET_ERRCODE_RTS(rtErr);
351 : }
352 1 : return ACL_SUCCESS;
353 : }
354 :
355 4 : aclError aclrtHostRegisterImpl(void *ptr, uint64_t size, aclrtHostRegisterType type, void **devPtr)
356 : {
357 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtHostRegister);
358 4 : ACL_LOG_DEBUG("start to execute aclrtHostRegister");
359 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(ptr);
360 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
361 : // size must be greater than zero
362 3 : if (size == 0UL) {
363 1 : ACL_LOG_ERROR("register size must be greater than zero");
364 3 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
365 2 : std::vector<const char *>({"param", "value", "reason"}),
366 2 : std::vector<const char *>({"size", std::to_string(size).c_str(), "size must be greater than zero"}));
367 1 : return ACL_ERROR_INVALID_PARAM;
368 : }
369 2 : const rtError_t rtErr = rtsHostRegister(ptr, size, static_cast<rtHostRegisterType>(type), devPtr);
370 2 : if (rtErr != RT_ERROR_NONE) {
371 1 : ACL_LOG_CALL_ERROR("call rtsHostRegister failed, runtime result = %d", rtErr);
372 1 : return ACL_GET_ERRCODE_RTS(rtErr);
373 : }
374 1 : return ACL_SUCCESS;
375 : }
376 :
377 5 : aclError aclrtHostRegisterV2Impl(void *ptr, uint64_t size, uint32_t flag)
378 : {
379 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtHostRegisterV2);
380 5 : ACL_LOG_DEBUG("start to execute aclrtHostRegisterV2");
381 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(ptr);
382 : // size must be greater than zero
383 4 : if (size == 0UL) {
384 1 : ACL_LOG_ERROR("register size must be greater than zero");
385 3 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
386 2 : std::vector<const char *>({"param", "value", "reason"}),
387 2 : std::vector<const char *>({"size", std::to_string(size).c_str(), "size must be greater than zero"}));
388 1 : return ACL_ERROR_INVALID_PARAM;
389 : }
390 3 : const rtError_t rtErr = rtHostRegisterV2(ptr, size, flag);
391 3 : if (rtErr != RT_ERROR_NONE) {
392 1 : ACL_LOG_CALL_ERROR("call rtHostRegisterV2 failed, runtime result = %d", rtErr);
393 1 : return ACL_GET_ERRCODE_RTS(rtErr);
394 : }
395 2 : return ACL_SUCCESS;
396 : }
397 :
398 4 : aclError aclrtHostGetDevicePointerImpl(void *pHost, void **pDevice, uint32_t flag)
399 : {
400 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtHostGetDevicePointer);
401 4 : ACL_LOG_DEBUG("start to execute aclrtHostGetDevicePointer");
402 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(pHost);
403 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(pDevice);
404 3 : if (flag != 0UL) {
405 1 : ACL_LOG_ERROR("register flag must be zero");
406 3 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
407 2 : std::vector<const char *>({"param", "value", "reason"}),
408 2 : std::vector<const char *>({"flag", std::to_string(flag).c_str(), "flag must be zero"}));
409 1 : return ACL_ERROR_INVALID_PARAM;
410 : }
411 2 : const rtError_t rtErr = rtHostGetDevicePointer(pHost, pDevice, flag);
412 2 : if (rtErr != RT_ERROR_NONE) {
413 1 : ACL_LOG_CALL_ERROR("call aclrtHostGetDevicePointer failed, runtime result = %d", rtErr);
414 1 : return ACL_GET_ERRCODE_RTS(rtErr);
415 : }
416 1 : return ACL_SUCCESS;
417 : }
418 :
419 3 : aclError aclrtHostUnregisterImpl(void *ptr)
420 : {
421 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtHostUnregister);
422 3 : ACL_LOG_DEBUG("start to execute aclrtHostUnregister");
423 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(ptr);
424 2 : const rtError_t rtErr = rtsHostUnregister(ptr);
425 2 : if (rtErr != RT_ERROR_NONE) {
426 1 : ACL_LOG_CALL_ERROR("call rtsHostUnregister failed, runtime result = %d", rtErr);
427 1 : return ACL_GET_ERRCODE_RTS(rtErr);
428 : }
429 1 : return ACL_SUCCESS;
430 : }
431 :
432 2 : aclError aclrtHostMemMapCapabilitiesImpl(uint32_t deviceId, aclrtHacType hacType,
433 : aclrtHostMemMapCapability *capabilities)
434 : {
435 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtHostMemMapCapabilities);
436 2 : ACL_LOG_DEBUG("start to execute aclrtHostMemMapCapabilities, deviceId = %u", deviceId);
437 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(capabilities);
438 2 : const rtError_t rtErr = rtHostMemMapCapabilities(deviceId, static_cast<rtHacType>(hacType),
439 : reinterpret_cast<rtHostMemMapCapability*>(capabilities));
440 2 : if (rtErr != RT_ERROR_NONE) {
441 1 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
442 0 : ACL_LOG_WARN("rtHostMemMapCapabilities not support this feature, runtime result = %d", static_cast<int32_t>(rtErr));
443 : } else {
444 1 : ACL_LOG_CALL_ERROR("call rtHostMemMapCapabilities failed, runtime result = %d", static_cast<int32_t>(rtErr));
445 : }
446 1 : return ACL_GET_ERRCODE_RTS(rtErr);
447 : }
448 1 : return ACL_SUCCESS;
449 : }
450 :
451 6 : aclError aclrtMemFlushImpl(void *devPtr, size_t size)
452 : {
453 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemFlush);
454 6 : ACL_LOG_DEBUG("start to execute aclrtMemFlush, size = %zu", size);
455 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
456 :
457 5 : if (size == 0UL) {
458 2 : ACL_LOG_INNER_ERROR("flush cache size must be greater than zero");
459 2 : return ACL_ERROR_INVALID_PARAM;
460 : }
461 3 : const rtError_t rtErr = rtFlushCache(devPtr, size);
462 3 : if (rtErr != RT_ERROR_NONE) {
463 2 : ACL_LOG_CALL_ERROR("flush cache data to ddr failed, runtime result = %d, size = %zu",
464 : static_cast<int32_t>(rtErr), size);
465 2 : return ACL_GET_ERRCODE_RTS(rtErr);
466 : }
467 1 : return ACL_SUCCESS;
468 : }
469 :
470 6 : aclError aclrtMemInvalidateImpl(void *devPtr, size_t size)
471 : {
472 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemInvalidate);
473 6 : ACL_LOG_INFO("start to execute aclrtMemInvalidate, size = %zu", size);
474 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
475 :
476 5 : if (size == 0UL) {
477 2 : ACL_LOG_INNER_ERROR("invalidate cache size must be greater than zero");
478 2 : return ACL_ERROR_INVALID_PARAM;
479 : }
480 3 : const rtError_t rtErr = rtInvalidCache(devPtr, size);
481 3 : if (rtErr != RT_ERROR_NONE) {
482 2 : ACL_LOG_CALL_ERROR("invalidate cache data failed, runtime result = %d, size = %zu",
483 : static_cast<int32_t>(rtErr), size);
484 2 : return ACL_GET_ERRCODE_RTS(rtErr);
485 : }
486 1 : return ACL_SUCCESS;
487 : }
488 :
489 21 : aclError aclrtFreeImpl(void *devPtr)
490 : {
491 42 : ACL_PROFILING_REG(acl::AclProfType::AclrtFree);
492 21 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
493 21 : ACL_LOG_DEBUG("start to execute aclrtFree");
494 21 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
495 :
496 20 : const rtError_t rtErr = rtFree(devPtr);
497 20 : if (rtErr != RT_ERROR_NONE) {
498 1 : ACL_LOG_CALL_ERROR("free device memory failed, runtime result = %d", rtErr);
499 1 : return ACL_GET_ERRCODE_RTS(rtErr);
500 : }
501 19 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
502 19 : return ACL_SUCCESS;
503 : }
504 :
505 13 : aclError aclrtMallocHostImpl(void **hostPtr, size_t size)
506 : {
507 26 : ACL_PROFILING_REG(acl::AclProfType::AclrtMallocHost);
508 13 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_HOST);
509 13 : ACL_LOG_DEBUG("start to execute aclrtMallocHost, size = %zu", size);
510 13 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(hostPtr);
511 : // size must be greater than zero
512 11 : if (size == 0UL) {
513 2 : ACL_LOG_INNER_ERROR("malloc size must be greater than zero");
514 2 : return ACL_ERROR_INVALID_PARAM;
515 : }
516 9 : const rtError_t rtErr = rtMallocHost(hostPtr, size, acl::APP_MODE_ID_U16);
517 9 : if (rtErr != RT_ERROR_NONE) {
518 2 : ACL_LOG_CALL_ERROR("alloc host memory failed, runtime result = %d", rtErr);
519 2 : return ACL_GET_ERRCODE_RTS(rtErr);
520 : }
521 7 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_HOST);
522 7 : return ACL_SUCCESS;
523 : }
524 :
525 2 : aclError aclrtMemAllocManagedImpl(void **ptr, uint64_t size, uint32_t flag)
526 : {
527 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemAllocManaged);
528 2 : ACL_LOG_DEBUG("start to execute aclrtMemAllocManaged");
529 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(ptr);
530 2 : if (flag != ACL_RT_MEM_ATTACH_GLOBAL) {
531 1 : ACL_LOG_INNER_ERROR("flag must be ACL_RT_MEM_ATTACH_GLOBAL");
532 1 : return ACL_ERROR_INVALID_PARAM;
533 : }
534 1 : const rtError_t rtErr = rtMemAllocManaged(ptr, size, RT_MEMORY_ATTACH_GLOBAL, acl::APP_MODE_ID_U16);
535 1 : if (rtErr != RT_ERROR_NONE) {
536 0 : ACL_LOG_CALL_ERROR("alloc uvm memory failed, runtime result = %d", rtErr);
537 0 : return ACL_GET_ERRCODE_RTS(rtErr);
538 : }
539 1 : return ACL_SUCCESS;
540 : }
541 :
542 7 : aclError aclrtFreeHostImpl(void *hostPtr)
543 : {
544 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtFreeHost);
545 7 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_HOST);
546 7 : ACL_LOG_DEBUG("start to execute aclrtFreeHost");
547 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(hostPtr);
548 6 : const rtError_t rtErr = rtFreeHost(hostPtr);
549 6 : if (rtErr != RT_ERROR_NONE) {
550 1 : ACL_LOG_CALL_ERROR("free host memory failed, runtime result = %d", rtErr);
551 1 : return ACL_GET_ERRCODE_RTS(rtErr);
552 : }
553 5 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_HOST);
554 5 : return ACL_SUCCESS;
555 : }
556 :
557 4 : aclError aclrtFreeWithDevSyncImpl(void *devPtr)
558 : {
559 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtFreeWithDevSync);
560 4 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
561 4 : ACL_LOG_DEBUG("start to execute aclrtFreeWithDevSync");
562 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
563 :
564 3 : const rtError_t rtErr = rtFreeWithDevSync(devPtr);
565 3 : if (rtErr != RT_ERROR_NONE) {
566 1 : ACL_LOG_CALL_ERROR("free device memory with device synchronize failed, runtime result = %d", rtErr);
567 1 : return ACL_GET_ERRCODE_RTS(rtErr);
568 : }
569 2 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE);
570 2 : return ACL_SUCCESS;
571 : }
572 :
573 4 : aclError aclrtFreeHostWithDevSyncImpl(void *hostPtr)
574 : {
575 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtFreeHostWithDevSync);
576 4 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_HOST);
577 4 : ACL_LOG_DEBUG("start to execute aclrtFreeHostWithDevSync");
578 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(hostPtr);
579 3 : const rtError_t rtErr = rtFreeHostWithDevSync(hostPtr);
580 3 : if (rtErr != RT_ERROR_NONE) {
581 1 : ACL_LOG_CALL_ERROR("free host memory with device synchronize failed, runtime result = %d", rtErr);
582 1 : return ACL_GET_ERRCODE_RTS(rtErr);
583 : }
584 2 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_HOST);
585 2 : return ACL_SUCCESS;
586 : }
587 :
588 10 : aclError aclrtMemcpyImpl(void *dst,
589 : size_t destMax,
590 : const void *src,
591 : size_t count,
592 : aclrtMemcpyKind kind)
593 : {
594 20 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpy);
595 10 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(dst);
596 9 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(src);
597 :
598 8 : rtMemcpyKind_t rtKind = RT_MEMCPY_RESERVED;
599 8 : const aclError ret = MemcpyKindTranslate(kind, rtKind);
600 8 : if (ret != ACL_SUCCESS) {
601 1 : ACL_LOG_INNER_ERROR("invalid kind of memcpy, kind = %d", static_cast<int32_t>(kind));
602 1 : return ret;
603 : }
604 :
605 7 : const rtError_t rtErr = rtMemcpy(dst, destMax, src, count, rtKind);
606 7 : if (rtErr != RT_ERROR_NONE) {
607 1 : ACL_LOG_CALL_ERROR("synchronized memcpy failed, kind = %d, runtime result = %d",
608 : static_cast<int32_t>(kind), static_cast<int32_t>(rtErr));
609 1 : return ACL_GET_ERRCODE_RTS(rtErr);
610 : }
611 6 : return ACL_SUCCESS;
612 : }
613 :
614 3 : aclError aclrtMemsetImpl(void *devPtr, size_t maxCount, int32_t value, size_t count)
615 : {
616 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemset);
617 3 : ACL_LOG_DEBUG("start to execute aclrtMemset, maxSize = %zu, size = %zu, value = %d",
618 : maxCount, count, value);
619 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
620 :
621 2 : const rtError_t rtErr = rtMemset(devPtr, maxCount, static_cast<uint32_t>(value), count);
622 2 : if (rtErr != RT_ERROR_NONE) {
623 1 : ACL_LOG_CALL_ERROR("set memory failed, runtime result = %d", static_cast<int32_t>(rtErr));
624 1 : return ACL_GET_ERRCODE_RTS(rtErr);
625 : }
626 1 : return ACL_SUCCESS;
627 : }
628 :
629 21 : aclError aclrtMemcpyAsyncImpl(void *dst,
630 : size_t destMax,
631 : const void *src,
632 : size_t count,
633 : aclrtMemcpyKind kind,
634 : aclrtStream stream)
635 : {
636 42 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpyAsync);
637 21 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(dst);
638 19 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(src);
639 17 : rtMemcpyKind_t rtKindVal = RT_MEMCPY_RESERVED;
640 17 : const aclError ret = MemcpyKindTranslate(kind, rtKindVal);
641 17 : if (ret != ACL_SUCCESS) {
642 2 : ACL_LOG_INNER_ERROR("invalid kind of memcpy, kind = %d", static_cast<int32_t>(kind));
643 2 : return ret;
644 : }
645 :
646 15 : ACL_REQUIRES_CALL_RTS_OK(rtMemcpyAsync(dst, destMax, src, count, rtKindVal, static_cast<rtStream_t>(stream)),
647 : rtMemcpyAsync);
648 13 : return ACL_SUCCESS;
649 : }
650 :
651 11 : aclError aclrtMemcpyAsyncWithConditionImpl(void *dst,
652 : size_t destMax,
653 : const void *src,
654 : size_t count,
655 : aclrtMemcpyKind kind,
656 : aclrtStream stream)
657 : {
658 22 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpyAsyncWithCondition);
659 11 : ACL_LOG_DEBUG("start to execute aclrtMemcpyAsyncWithCondition, destMaxSize = %zu, srcSize = %zu, kind = %d",
660 : destMax, count, static_cast<int32_t>(kind));
661 11 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(dst);
662 10 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(src);
663 9 : rtMemcpyKind_t rtKindVal = RT_MEMCPY_RESERVED;
664 9 : const aclError ret = MemcpyKindTranslate(kind, rtKindVal);
665 9 : if (ret != ACL_SUCCESS) {
666 1 : ACL_LOG_INNER_ERROR("invalid kind of memcpy, kind = %d", static_cast<int32_t>(kind));
667 1 : return ret;
668 : }
669 :
670 8 : rtMemcpyAttributeValue_t memcpyAttrValue;
671 : // bit0 standing for not checking matching between address and kind, bit1 standing for checking page-locked addr
672 8 : memcpyAttrValue.checkBitmap = 0x00000002U;
673 8 : rtMemcpyAttribute_t memcpyAttr = {
674 : .id = RT_MEMCPY_ATTRIBUTE_CHECK,
675 : .value = memcpyAttrValue
676 8 : };
677 8 : rtMemcpyConfig_t memcpyConfig = {
678 : .attrs = &memcpyAttr,
679 : .numAttrs = 1U
680 8 : };
681 :
682 8 : ACL_REQUIRES_CALL_RTS_OK(rtMemcpyAsyncEx(dst, destMax, src, count, rtKindVal, static_cast<rtStream_t>(stream),
683 : &memcpyConfig), rtMemcpyAsyncEx);
684 7 : return ACL_SUCCESS;
685 : }
686 :
687 6 : aclError aclrtMemsetAsyncImpl(void *devPtr, size_t maxCount, int32_t value, size_t count, aclrtStream stream)
688 : {
689 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemsetAsync);
690 6 : ACL_LOG_DEBUG("start to execute aclrtMemsetAsync, maxCount = %zu, value = %d, count = %zu",
691 : maxCount, value, count);
692 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
693 :
694 4 : ACL_REQUIRES_CALL_RTS_OK(rtMemsetAsync(devPtr, maxCount, static_cast<uint32_t>(value), count, stream),
695 : rtMemsetAsync);
696 2 : return ACL_SUCCESS;
697 : }
698 :
699 8 : aclError aclrtDeviceCanAccessPeerImpl(int32_t *canAccessPeer, int32_t deviceId, int32_t peerDeviceId)
700 : {
701 16 : ACL_PROFILING_REG(acl::AclProfType::AclrtDeviceCanAccessPeer);
702 8 : ACL_LOG_INFO("start to execute aclrtDeviceCanAccessPeer");
703 :
704 8 : if (deviceId == peerDeviceId) {
705 2 : ACL_LOG_INNER_ERROR("deviceId shouldn't be equal to peeerDeviceId");
706 2 : return ACL_ERROR_INVALID_PARAM;
707 : }
708 :
709 6 : uint32_t peerPhyId = 0U;
710 6 : rtError_t rtErr = rtGetDevicePhyIdByIndex(static_cast<uint32_t>(peerDeviceId), &peerPhyId);
711 6 : if (rtErr != RT_ERROR_NONE) {
712 2 : ACL_LOG_CALL_ERROR("call rtGetDevicePhyIdByIndex failed, deviceId = %d, peerDeviceId = %d, "
713 : "runtime result = %d", deviceId, peerDeviceId, static_cast<int32_t>(rtErr));
714 2 : return ACL_GET_ERRCODE_RTS(rtErr);
715 : }
716 :
717 4 : rtErr = rtDeviceCanAccessPeer(canAccessPeer, static_cast<uint32_t>(deviceId), peerPhyId);
718 4 : if (rtErr != RT_ERROR_NONE) {
719 2 : ACL_LOG_CALL_ERROR("call rtDeviceCanAccessPeer failed, deviceId = %d, peerPhyId = %u, "
720 : "runtime result = %d", deviceId, peerPhyId, static_cast<int32_t>(rtErr));
721 2 : return ACL_GET_ERRCODE_RTS(rtErr);
722 : }
723 :
724 2 : return ACL_SUCCESS;
725 : }
726 :
727 10 : aclError aclrtDeviceEnablePeerAccessImpl(int32_t peerDeviceId, uint32_t flags)
728 : {
729 20 : ACL_PROFILING_REG(acl::AclProfType::AclrtDeviceEnablePeerAccess);
730 10 : ACL_LOG_INFO("start to execute aclrtDeviceEnablePeerAccess");
731 :
732 10 : if (flags != 0U) {
733 2 : ACL_LOG_INNER_ERROR("the flags must be 0, but current is %u", flags);
734 2 : return ACL_ERROR_FEATURE_UNSUPPORTED;
735 : }
736 :
737 8 : int32_t deviceId = 0;
738 8 : rtError_t rtErr = rtGetDevice(&deviceId);
739 8 : if (rtErr != RT_ERROR_NONE) {
740 2 : ACL_LOG_CALL_ERROR("call rtGetDevice failed, runtime result = %d", static_cast<int32_t>(rtErr));
741 2 : return ACL_GET_ERRCODE_RTS(rtErr);
742 : }
743 :
744 6 : if (deviceId == peerDeviceId) {
745 1 : ACL_LOG_INNER_ERROR("deviceId shouldn't be equal to peeerDeviceId, deviceId = %d, peerDeviceId = %d",
746 : deviceId, peerDeviceId);
747 1 : return ACL_ERROR_INVALID_PARAM;
748 : }
749 :
750 5 : uint32_t peerPhyId = 0U;
751 5 : rtErr = rtGetDevicePhyIdByIndex(static_cast<uint32_t>(peerDeviceId), &peerPhyId);
752 5 : if (rtErr != RT_ERROR_NONE) {
753 2 : ACL_LOG_CALL_ERROR("call rtGetDevicePhyIdByIndex failed, peerDeviceId = %d, runtime result = %d",
754 : peerDeviceId, static_cast<int32_t>(rtErr));
755 2 : return ACL_GET_ERRCODE_RTS(rtErr);
756 : }
757 :
758 3 : rtErr = rtEnableP2P(static_cast<uint32_t>(deviceId), peerPhyId, flags);
759 3 : if (rtErr != RT_ERROR_NONE) {
760 2 : ACL_LOG_CALL_ERROR("call rtEnableP2P failed, deviceId = %d, peerPhyId = %u, runtime result = %d",
761 : deviceId, peerPhyId, static_cast<int32_t>(rtErr));
762 2 : return ACL_GET_ERRCODE_RTS(rtErr);
763 : }
764 :
765 1 : return ACL_SUCCESS;
766 : }
767 :
768 9 : aclError aclrtDeviceDisablePeerAccessImpl(int32_t peerDeviceId)
769 : {
770 18 : ACL_PROFILING_REG(acl::AclProfType::AclrtDeviceDisablePeerAccess);
771 9 : ACL_LOG_INFO("start to execute aclrtDeviceDisablePeerAccess");
772 :
773 9 : int32_t deviceId = 0;
774 9 : rtError_t rtErr = rtGetDevice(&deviceId);
775 9 : if (rtErr != RT_ERROR_NONE) {
776 2 : ACL_LOG_CALL_ERROR("call rtGetDevice failed, runtime result = %d", static_cast<int32_t>(rtErr));
777 2 : return ACL_GET_ERRCODE_RTS(rtErr);
778 : }
779 :
780 7 : if (deviceId == peerDeviceId) {
781 2 : ACL_LOG_INNER_ERROR("deviceId shouldn't be equal to peeerDeviceId, deviceId = %d, peerDeviceId = %d",
782 : deviceId, peerDeviceId);
783 2 : return ACL_ERROR_INVALID_PARAM;
784 : }
785 :
786 5 : uint32_t peerPhyId = 0U;
787 5 : rtErr = rtGetDevicePhyIdByIndex(static_cast<uint32_t>(peerDeviceId), &peerPhyId);
788 5 : if (rtErr != RT_ERROR_NONE) {
789 2 : ACL_LOG_CALL_ERROR("call rtGetDevicePhyIdByIndex failed, peerDeviceId = %u, runtime result = %d",
790 : peerDeviceId, static_cast<int32_t>(rtErr));
791 2 : return ACL_GET_ERRCODE_RTS(rtErr);
792 : }
793 :
794 3 : rtErr = rtDisableP2P(static_cast<uint32_t>(deviceId), peerPhyId);
795 3 : if (rtErr != RT_ERROR_NONE) {
796 2 : ACL_LOG_CALL_ERROR("call rtDisableP2P failed, deviceId = %d, peerPhyId = %u, runtime result = %d",
797 : deviceId, peerPhyId, static_cast<int32_t>(rtErr));
798 2 : return ACL_GET_ERRCODE_RTS(rtErr);
799 : }
800 :
801 1 : return ACL_SUCCESS;
802 : }
803 :
804 7 : aclError aclrtGetMemInfoImpl(aclrtMemAttr attr, size_t *free, size_t *total)
805 : {
806 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetMemInfo);
807 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(free);
808 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(total);
809 7 : ACL_LOG_DEBUG("start to execute aclrtGetMemInfo, memory attribute = %d", static_cast<int32_t>(attr));
810 :
811 7 : const rtError_t rtErr = rtMemGetInfoEx(static_cast<rtMemInfoType_t>(attr), free, total);
812 7 : if (rtErr != RT_ERROR_NONE) {
813 2 : ACL_LOG_CALL_ERROR("get memory information failed, runtime result = %d", static_cast<int32_t>(rtErr));
814 2 : return ACL_GET_ERRCODE_RTS(rtErr);
815 : }
816 :
817 5 : ACL_LOG_DEBUG("successfully execute aclrtGetMemInfo, memory attribute = %d, free memory = %zu bytes, "
818 : "total memory = %zu bytes", static_cast<int32_t>(attr), *free, *total);
819 5 : return ACL_SUCCESS;
820 : }
821 :
822 2 : aclError aclrtGetMemUsageInfoImpl(int32_t deviceId, aclrtMemUsageInfo *memUsageInfo, size_t inputNum, size_t *outputNum)
823 : {
824 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetMemUsageInfo);
825 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(memUsageInfo);
826 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(outputNum);
827 2 : ACL_LOG_DEBUG("start to execute aclrtGetMemUsageInfo, deviceId = %d, inputNum = %zu", static_cast<int32_t>(deviceId), inputNum);
828 :
829 2 : const rtError_t rtErr = rtGetMemUsageInfo(static_cast<uint32_t>(deviceId), reinterpret_cast<rtMemUsageInfo_t*>(memUsageInfo), inputNum, outputNum);
830 2 : if (rtErr != RT_ERROR_NONE) {
831 1 : ACL_LOG_CALL_ERROR("get memory usage information failed, runtime result = %d", static_cast<int32_t>(rtErr));
832 1 : return ACL_GET_ERRCODE_RTS(rtErr);
833 : }
834 :
835 1 : ACL_LOG_DEBUG("successfully execute aclrtGetMemUsageInfo, deviceId = %d, inputNum = %zu", deviceId, inputNum);
836 1 : return ACL_SUCCESS;
837 : }
838 :
839 7 : aclError aclrtMemcpy2dImpl(void *dst,
840 : size_t dpitch,
841 : const void *src,
842 : size_t spitch,
843 : size_t width,
844 : size_t height,
845 : aclrtMemcpyKind kind)
846 : {
847 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpy2d);
848 7 : ACL_LOG_DEBUG("start to execute aclrtMemcpy2d, dpitch = %zu, spitch = %zu, width = %zu, height = %zu, kind = %d",
849 : dpitch, spitch, width, height, static_cast<int32_t>(kind));
850 :
851 7 : rtMemcpyKind_t rtKind = RT_MEMCPY_RESERVED;
852 7 : const aclError ret = CheckMemcpy2dParam(dst, dpitch, src, spitch, width, height, kind, rtKind);
853 7 : if (ret != ACL_SUCCESS) {
854 4 : return ret;
855 : }
856 :
857 3 : const rtError_t rtErr = rtMemcpy2d(dst, dpitch, src, spitch, width, height, rtKind);
858 3 : if (rtErr != RT_ERROR_NONE) {
859 1 : ACL_LOG_CALL_ERROR("[Synchronized][Memcpy]synchronized memcpy failed, kind = %d, runtime result = %d",
860 : static_cast<int32_t>(kind), static_cast<int32_t>(rtErr));
861 1 : return ACL_GET_ERRCODE_RTS(rtErr);
862 : }
863 :
864 2 : ACL_LOG_DEBUG("Successfuly execute aclrtMemcpy2d, dpitch = %zu, spitch = %zu, width = %zu, height = %zu, "
865 : "kind = %d", dpitch, spitch, width, height, static_cast<int32_t>(kind));
866 2 : return ACL_SUCCESS;
867 : }
868 :
869 8 : aclError aclrtMemcpy2dAsyncImpl(void *dst,
870 : size_t dpitch,
871 : const void *src,
872 : size_t spitch,
873 : size_t width,
874 : size_t height,
875 : aclrtMemcpyKind kind,
876 : aclrtStream stream)
877 : {
878 16 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpy2dAsync);
879 8 : ACL_LOG_DEBUG("start to execute aclrtMemcpy2dAsync, dpitch = %zu, spitch = %zu, width = %zu, height = %zu,"
880 : " kind = %d", dpitch, spitch, width, height, static_cast<int32_t>(kind));
881 :
882 8 : rtMemcpyKind_t rtKindVal = RT_MEMCPY_RESERVED;
883 8 : const aclError ret = CheckMemcpy2dParam(dst, dpitch, src, spitch, width, height, kind, rtKindVal);
884 8 : if (ret != ACL_SUCCESS) {
885 4 : return ret;
886 : }
887 :
888 4 : ACL_REQUIRES_CALL_RTS_OK(rtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, rtKindVal, stream),
889 : rtMemcpy2dAsync);
890 :
891 3 : ACL_LOG_DEBUG("Successfuly execute aclrtMemcpy2dAsync, dpitch = %zu, spitch = %zu, width = %zu, height = %zu, "
892 : "kind = %d", dpitch, spitch, width, height, static_cast<int32_t>(kind));
893 3 : return ACL_SUCCESS;
894 : }
895 :
896 10 : aclError aclrtReserveMemAddressImpl(void **virPtr,
897 : size_t size,
898 : size_t alignment,
899 : void *expectPtr,
900 : uint64_t flags)
901 : {
902 20 : ACL_PROFILING_REG(acl::AclProfType::AclrtReserveMemAddress);
903 10 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_RESERVE_RELEASE_MEMORY_ADDRESS);
904 10 : ACL_LOG_DEBUG("start to execute aclrtReserveMemAddress, size = %zu", size);
905 10 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(virPtr);
906 :
907 10 : if (size == 0UL) {
908 1 : ACL_LOG_ERROR("reserve size must be greater than zero");
909 1 : return ACL_ERROR_INVALID_PARAM;
910 : }
911 9 : if ((flags != 1ULL) && (flags != 0ULL)) {
912 1 : ACL_LOG_ERROR("flags of page type must be 0 or 1");
913 1 : return ACL_ERROR_INVALID_PARAM;
914 : }
915 :
916 8 : const rtError_t rtErr = rtReserveMemAddress(virPtr, size, alignment, expectPtr, flags);
917 8 : if (rtErr != RT_ERROR_NONE) {
918 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
919 1 : ACL_LOG_WARN("reserve memory address unsupport, runtime result = %d", static_cast<int32_t>(rtErr));
920 : } else {
921 1 : ACL_LOG_CALL_ERROR("reserve memory address failed, runtime result = %d", static_cast<int32_t>(rtErr));
922 : }
923 2 : return ACL_GET_ERRCODE_RTS(rtErr);
924 : }
925 6 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_RESERVE_RELEASE_MEMORY_ADDRESS);
926 6 : return ACL_SUCCESS;
927 : }
928 :
929 8 : aclError aclrtReleaseMemAddressImpl(void *virPtr)
930 : {
931 16 : ACL_PROFILING_REG(acl::AclProfType::AclrtReleaseMemAddress);
932 8 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_RESERVE_RELEASE_MEMORY_ADDRESS);
933 8 : ACL_LOG_DEBUG("start to execute aclrtReleaseMemAddress");
934 8 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(virPtr);
935 :
936 8 : const rtError_t rtErr = rtReleaseMemAddress(virPtr);
937 8 : if (rtErr != RT_ERROR_NONE) {
938 2 : ACL_LOG_CALL_ERROR("release memory address failed, runtime result = %d", static_cast<int32_t>(rtErr));
939 2 : return ACL_GET_ERRCODE_RTS(rtErr);
940 : }
941 6 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_RESERVE_RELEASE_MEMORY_ADDRESS);
942 6 : return ACL_SUCCESS;
943 : }
944 :
945 34 : aclError aclrtMallocPhysicalImpl(aclrtDrvMemHandle *handle,
946 : size_t size,
947 : const aclrtPhysicalMemProp *prop,
948 : uint64_t flags)
949 : {
950 68 : ACL_PROFILING_REG(acl::AclProfType::AclrtMallocPhysical);
951 34 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_PHYSICAL_MEMORY);
952 34 : ACL_LOG_DEBUG("start to execute aclrtMallocPhysical, size = %zu", size);
953 34 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
954 34 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(prop);
955 34 : ACL_CHECK_WITH_MESSAGE_AND_RETURN(size != 0UL, ACL_ERROR_INVALID_PARAM,
956 : "malloc size must be greater than zero");
957 33 : ACL_CHECK_WITH_MESSAGE_AND_RETURN(flags == 0UL, ACL_ERROR_INVALID_PARAM,
958 : "flags must be 0");
959 32 : ACL_CHECK_WITH_MESSAGE_AND_RETURN(prop->handleType == ACL_MEM_HANDLE_TYPE_NONE,
960 : ACL_ERROR_INVALID_PARAM, "handleType must be ACL_MEM_HANDLE_TYPE_NONE");
961 31 : ACL_CHECK_WITH_MESSAGE_AND_RETURN(prop->allocationType == ACL_MEM_ALLOCATION_TYPE_PINNED,
962 : ACL_ERROR_INVALID_PARAM,
963 : "allocationType must be ACL_MEM_ALLOCATION_TYPE_PINNED");
964 29 : ACL_CHECK_WITH_MESSAGE_AND_RETURN(prop->location.type != ACL_MEM_LOCATION_TYPE_UNREGISTERED,
965 : ACL_ERROR_INVALID_PARAM,
966 : "locationType does not support ACL_MEM_LOCATION_TYPE_UNREGISTERED");
967 :
968 29 : rtDrvMemProp_t rtProp = {};
969 29 : rtProp.side = prop->location.type;
970 29 : rtProp.devid = prop->location.id;
971 29 : rtProp.module_id = acl::APP_MODE_ID_U16;
972 29 : rtProp.reserve = prop->reserve;
973 : // host alloc
974 29 : bool isHostAlloc = (prop->location.type == ACL_MEM_LOCATION_TYPE_HOST) || (prop->location.type == ACL_MEM_LOCATION_TYPE_HOST_NUMA);
975 : // device alloc
976 29 : bool isDeviceAlloc = (prop->location.type == ACL_MEM_LOCATION_TYPE_DEVICE);
977 29 : if (isDeviceAlloc && ((prop->memAttr == ACL_DDR_MEM_HUGE) || (prop->memAttr == ACL_DDR_MEM_NORMAL) || (prop->memAttr == ACL_DDR_MEM_P2P_HUGE)
978 18 : || (prop->memAttr == ACL_DDR_MEM_P2P_NORMAL))) {
979 1 : ACL_LOG_ERROR("memAttr [%d] only support ACL_MEM_LOCATION_TYPE_HOST/ACL_MEM_LOCATION_TYPE_HOST_NUMA.", static_cast<int32_t>(prop->memAttr));
980 1 : return ACL_ERROR_INVALID_PARAM;
981 : }
982 28 : auto it = memAttrHandlers.find(static_cast<int32_t>(prop->memAttr));
983 28 : if (it != memAttrHandlers.end()) {
984 26 : it->second(rtProp, isHostAlloc, isDeviceAlloc);
985 : } else {
986 2 : ACL_LOG_ERROR("memAttr [%d] not support. "
987 : "For details, please refer to the manual.",
988 : static_cast<int32_t>(prop->memAttr));
989 2 : return ACL_ERROR_INVALID_PARAM;
990 : }
991 :
992 26 : const rtError_t rtErr = rtMallocPhysical(reinterpret_cast<rtDrvMemHandle*>(handle), size, &rtProp, flags);
993 26 : if (rtErr != RT_ERROR_NONE) {
994 1 : ACL_LOG_CALL_ERROR("malloc physical memory failed, runtime result = %d", static_cast<int32_t>(rtErr));
995 1 : return ACL_GET_ERRCODE_RTS(rtErr);
996 : }
997 25 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_PHYSICAL_MEMORY);
998 25 : return ACL_SUCCESS;
999 : }
1000 :
1001 6 : aclError aclrtFreePhysicalImpl(aclrtDrvMemHandle handle)
1002 : {
1003 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtFreePhysical);
1004 6 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_PHYSICAL_MEMORY);
1005 6 : ACL_LOG_DEBUG("start to execute aclrtFreePhysical");
1006 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
1007 :
1008 6 : const rtError_t rtErr = rtFreePhysical(reinterpret_cast<rtDrvMemHandle>(handle));
1009 6 : if (rtErr != RT_ERROR_NONE) {
1010 1 : ACL_LOG_CALL_ERROR("free physical memory failed, runtime result = %d", static_cast<int32_t>(rtErr));
1011 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1012 : }
1013 5 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_MALLOC_FREE_PHYSICAL_MEMORY);
1014 5 : return ACL_SUCCESS;
1015 : }
1016 :
1017 6 : aclError aclrtMapMemImpl(void *virPtr,
1018 : size_t size,
1019 : size_t offset,
1020 : aclrtDrvMemHandle handle,
1021 : uint64_t flags)
1022 : {
1023 12 : ACL_PROFILING_REG(acl::AclProfType::AclrtMapMem);
1024 6 : ACL_ADD_APPLY_TOTAL_COUNT(acl::ACL_STATISTICS_MAP_UNMAP_MEMORY);
1025 6 : ACL_LOG_DEBUG("start to execute aclrtMapMem, size = %zu, offset = %zu", size, offset);
1026 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(virPtr);
1027 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
1028 :
1029 6 : if (size == 0UL) {
1030 1 : ACL_LOG_ERROR("map size must be greater than zero");
1031 1 : return ACL_ERROR_INVALID_PARAM;
1032 : }
1033 5 : if (flags != 0UL) {
1034 1 : ACL_LOG_ERROR("flags must be 0");
1035 1 : return ACL_ERROR_INVALID_PARAM;
1036 : }
1037 :
1038 4 : const rtError_t rtErr = rtMapMem(virPtr, size, offset, reinterpret_cast<rtDrvMemHandle>(handle), flags);
1039 4 : if (rtErr != RT_ERROR_NONE) {
1040 1 : ACL_LOG_CALL_ERROR("map memory failed, runtime result = %d", static_cast<int32_t>(rtErr));
1041 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1042 : }
1043 3 : ACL_ADD_APPLY_SUCCESS_COUNT(acl::ACL_STATISTICS_MAP_UNMAP_MEMORY);
1044 3 : return ACL_SUCCESS;
1045 : }
1046 :
1047 4 : aclError aclrtUnmapMemImpl(void *virPtr)
1048 : {
1049 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtUnmapMem);
1050 4 : ACL_ADD_RELEASE_TOTAL_COUNT(acl::ACL_STATISTICS_MAP_UNMAP_MEMORY);
1051 4 : ACL_LOG_DEBUG("start to execute aclrtUnmapMem");
1052 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(virPtr);
1053 :
1054 4 : const rtError_t rtErr = rtUnmapMem(virPtr);
1055 4 : if (rtErr != RT_ERROR_NONE) {
1056 1 : ACL_LOG_CALL_ERROR("unmap memory failed, runtime result = %d", static_cast<int32_t>(rtErr));
1057 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1058 : }
1059 3 : ACL_ADD_RELEASE_SUCCESS_COUNT(acl::ACL_STATISTICS_MAP_UNMAP_MEMORY);
1060 3 : return ACL_SUCCESS;
1061 : }
1062 :
1063 2 : aclError aclrtMemGetAccessImpl(void *virPtr, aclrtMemLocation *location, uint64_t *flag)
1064 : {
1065 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemGetAccess);
1066 2 : ACL_LOG_DEBUG("start to execute aclrtMemGetAccess");
1067 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(virPtr);
1068 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(location);
1069 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(flag);
1070 :
1071 2 : const rtError_t rtErr = rtMemGetAccess(virPtr, reinterpret_cast<rtMemLocation*>(location), flag);
1072 2 : if (rtErr != ACL_RT_SUCCESS) {
1073 1 : ACL_LOG_CALL_ERROR("get access failed, runtime result = %d", static_cast<int32_t>(rtErr));
1074 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1075 : }
1076 1 : return ACL_SUCCESS;
1077 : }
1078 :
1079 4 : aclError aclrtMemExportToShareableHandleImpl(aclrtDrvMemHandle handle, aclrtMemHandleType handleType,
1080 : uint64_t flags, uint64_t *shareableHandle)
1081 : {
1082 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemExportToShareableHandle);
1083 4 : ACL_LOG_DEBUG("start to execute aclrtMemExportToShareableHandle");
1084 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
1085 3 : ACL_REQUIRES_TRUE(handleType == ACL_MEM_HANDLE_TYPE_NONE, ACL_ERROR_INVALID_PARAM,
1086 : "handleType in MemExportToShareableHandle must be ACL_MEM_HANDLE_TYPE_NONE !");
1087 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(shareableHandle);
1088 :
1089 2 : const rtError_t rtErr = rtsMemExportToShareableHandle(reinterpret_cast<rtDrvMemHandle>(handle),
1090 : RT_MEM_HANDLE_TYPE_NONE, flags, shareableHandle);
1091 2 : if (rtErr != RT_ERROR_NONE) {
1092 1 : ACL_LOG_CALL_ERROR("export shareable handle failed, runtime result = %d", static_cast<int32_t>(rtErr));
1093 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1094 : }
1095 1 : return ACL_SUCCESS;
1096 : }
1097 :
1098 3 : aclError aclrtMemExportToShareableHandleV2Impl(aclrtDrvMemHandle handle, uint64_t flags,
1099 : aclrtMemSharedHandleType shareType, void *shareableHandle)
1100 : {
1101 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemExportToShareableHandleV2);
1102 3 : ACL_LOG_DEBUG("start to execute aclrtMemExportToShareableHandleV2");
1103 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
1104 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(shareableHandle);
1105 :
1106 2 : const rtError_t rtErr = rtMemExportToShareableHandleV2(reinterpret_cast<rtDrvMemHandle>(handle),
1107 : static_cast<rtMemSharedHandleType>(shareType), flags, shareableHandle);
1108 2 : if (rtErr != ACL_RT_SUCCESS) {
1109 1 : ACL_LOG_CALL_ERROR("export shareable handle failed, runtime result = %d", static_cast<int32_t>(rtErr));
1110 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1111 : }
1112 1 : return ACL_SUCCESS;
1113 : }
1114 :
1115 3 : aclError aclrtMemImportFromShareableHandleImpl(uint64_t shareableHandle,
1116 : int32_t deviceId, aclrtDrvMemHandle *handle)
1117 : {
1118 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemImportFromShareableHandle);
1119 3 : ACL_LOG_DEBUG("start to execute aclrtMemImportFromShareableHandle");
1120 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
1121 :
1122 2 : const rtError_t rtErr = rtMemImportFromShareableHandle(shareableHandle, deviceId,
1123 : reinterpret_cast<rtDrvMemHandle*>(handle));
1124 2 : if (rtErr != RT_ERROR_NONE) {
1125 1 : ACL_LOG_CALL_ERROR("import from shareable handle failed, shareableHandle[%lu], deviceId[%d], runtime result = %d",
1126 : shareableHandle, deviceId, static_cast<int32_t>(rtErr));
1127 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1128 : }
1129 1 : return ACL_SUCCESS;
1130 : }
1131 :
1132 4 : aclError aclrtMemImportFromShareableHandleV2Impl(void *shareableHandle, aclrtMemSharedHandleType shareType,
1133 : uint64_t flags, aclrtDrvMemHandle *handle)
1134 : {
1135 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemImportFromShareableHandleV2);
1136 4 : ACL_LOG_DEBUG("start to execute aclrtMemImportFromShareableHandleV2");
1137 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(shareableHandle);
1138 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
1139 3 : ACL_REQUIRES_TRUE(flags == 0UL, ACL_ERROR_INVALID_PARAM,
1140 : "flags in aclrtMemImportFromShareableHandleV2 must be 0 !");
1141 :
1142 2 : int32_t deviceId = 0;
1143 2 : const rtError_t rtRet = rtsGetDevice(&deviceId);
1144 2 : if (rtRet != ACL_RT_SUCCESS) {
1145 0 : return rtRet;
1146 : }
1147 :
1148 2 : const rtError_t rtErr = rtMemImportFromShareableHandleV2(shareableHandle,
1149 : static_cast<rtMemSharedHandleType>(shareType), flags, deviceId, reinterpret_cast<rtDrvMemHandle*>(handle));
1150 2 : if (rtErr != ACL_RT_SUCCESS) {
1151 1 : ACL_LOG_CALL_ERROR("import from shareable handle failed, shareableHandle[%lu], deviceId[%d], runtime result = %d",
1152 : *(static_cast<uint64_t*>(shareableHandle)), deviceId, static_cast<int32_t>(rtErr));
1153 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1154 : }
1155 1 : return ACL_SUCCESS;
1156 : }
1157 :
1158 4 : aclError aclrtMemSetPidToShareableHandleImpl(uint64_t shareableHandle, int32_t *pid, size_t pidNum)
1159 : {
1160 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemSetPidToShareableHandle);
1161 4 : ACL_LOG_DEBUG("start to execute aclrtMemSetPidToShareableHandle");
1162 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(pid);
1163 3 : ACL_REQUIRES_TRUE(pidNum > 0UL, ACL_ERROR_INVALID_PARAM,
1164 : "pidNum in SetPidToShareableHandle must be large than 0 !");
1165 :
1166 2 : const rtError_t rtErr = rtMemSetPidToShareableHandle(shareableHandle, pid, static_cast<uint32_t>(pidNum));
1167 2 : if (rtErr != RT_ERROR_NONE) {
1168 1 : ACL_LOG_CALL_ERROR("set pid to shareable handle failed, shareableHandle[%lu], pidNum[%zu], runtime result = %d",
1169 : shareableHandle, pidNum, static_cast<int32_t>(rtErr));
1170 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1171 : }
1172 1 : return ACL_SUCCESS;
1173 : }
1174 :
1175 4 : aclError aclrtMemSetPidToShareableHandleV2Impl(void *shareableHandle, aclrtMemSharedHandleType shareType,
1176 : int32_t *pid, size_t pidNum)
1177 : {
1178 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemSetPidToShareableHandleV2);
1179 4 : ACL_LOG_DEBUG("start to execute AclrtMemSetPidToShareableHandleV2");
1180 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(shareableHandle);
1181 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(pid);
1182 3 : ACL_REQUIRES_TRUE(pidNum > 0UL, ACL_ERROR_INVALID_PARAM,
1183 : "pidNum in SetPidToShareableHandle must be large than 0 !");
1184 :
1185 2 : const rtError_t rtErr = rtMemSetPidToShareableHandleV2(shareableHandle,
1186 : static_cast<rtMemSharedHandleType>(shareType), pid, static_cast<uint32_t>(pidNum));
1187 2 : if (rtErr != ACL_RT_SUCCESS) {
1188 1 : ACL_LOG_CALL_ERROR("set pid to shareable handle failed, shareableHandle[%lu], pidNum[%zu], runtime result = %d",
1189 : *(static_cast<uint64_t*>(shareableHandle)), pidNum, static_cast<int32_t>(rtErr));
1190 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1191 : }
1192 1 : return ACL_SUCCESS;
1193 : }
1194 :
1195 7 : aclError aclrtMemGetAllocationGranularityImpl(aclrtPhysicalMemProp *prop, aclrtMemGranularityOptions option,
1196 : size_t *granularity)
1197 : {
1198 14 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemGetAllocationGranularity);
1199 7 : ACL_LOG_DEBUG("start to execute aclrtMemGetAllocationGranularity");
1200 7 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(prop);
1201 6 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(granularity);
1202 :
1203 5 : rtDrvMemProp_t rtProp1 = {};
1204 5 : rtProp1.side = prop->location.type;
1205 5 : rtProp1.devid = prop->location.id;
1206 5 : rtProp1.module_id = acl::APP_MODE_ID_U16;
1207 5 : rtProp1.reserve = prop->reserve;
1208 : // host alloc
1209 5 : bool isHostAlloc = (prop->location.type == ACL_MEM_LOCATION_TYPE_HOST) || (prop->location.type == ACL_MEM_LOCATION_TYPE_HOST_NUMA);
1210 : // device alloc
1211 5 : bool isDeviceAlloc = (prop->location.type == ACL_MEM_LOCATION_TYPE_DEVICE);
1212 5 : if (isDeviceAlloc && ((prop->memAttr == ACL_DDR_MEM_HUGE) || (prop->memAttr == ACL_DDR_MEM_NORMAL) || (prop->memAttr == ACL_DDR_MEM_P2P_HUGE)
1213 0 : || (prop->memAttr == ACL_DDR_MEM_P2P_NORMAL))) {
1214 0 : ACL_LOG_ERROR("memAttr [%d] only support ACL_MEM_LOCATION_TYPE_HOST/ACL_MEM_LOCATION_TYPE_HOST_NUMA.", static_cast<int32_t>(prop->memAttr));
1215 0 : return ACL_ERROR_INVALID_PARAM;
1216 : }
1217 5 : auto it = memAttrHandlers.find(static_cast<int32_t>(prop->memAttr));
1218 5 : if (it != memAttrHandlers.end()) {
1219 4 : it->second(rtProp1, isHostAlloc, isDeviceAlloc);
1220 : } else {
1221 1 : ACL_LOG_ERROR("memAttr [%d] not support. "
1222 : "For details, please refer to the manual.",
1223 : static_cast<int32_t>(prop->memAttr));
1224 1 : return ACL_ERROR_INVALID_PARAM;
1225 : }
1226 :
1227 4 : const rtError_t rtErr = rtMemGetAllocationGranularity(&rtProp1,
1228 : static_cast<rtDrvMemGranularityOptions>(option), granularity);
1229 4 : if (rtErr != RT_ERROR_NONE) {
1230 1 : ACL_LOG_CALL_ERROR("Get Allocation Granularity failed, runtime result = %d", static_cast<int32_t>(rtErr));
1231 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1232 : }
1233 3 : return ACL_SUCCESS;
1234 : }
1235 :
1236 3 : aclError aclrtDeviceGetBareTgidImpl(int32_t *pid)
1237 : {
1238 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtDeviceGetBareTgid);
1239 3 : ACL_LOG_DEBUG("start to execute aclrtDeviceGetBareTgid");
1240 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(pid);
1241 :
1242 2 : const rtError_t rtErr = rtDeviceGetBareTgid(reinterpret_cast<uint32_t *>(pid));
1243 2 : if (rtErr != RT_ERROR_NONE) {
1244 1 : ACL_LOG_CALL_ERROR("Get Bare Tgid Falied, runtime result = %d", static_cast<int32_t>(rtErr));
1245 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1246 : }
1247 1 : return ACL_SUCCESS;
1248 : }
1249 :
1250 4 : aclError aclrtCmoAsyncImpl(void *src, size_t size, aclrtCmoType cmoType, aclrtStream stream)
1251 : {
1252 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtCmoAsync);
1253 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(src);
1254 3 : if (size == 0UL) {
1255 1 : ACL_LOG_ERROR("size must be greater than zero");
1256 1 : return ACL_ERROR_INVALID_PARAM;
1257 : }
1258 2 : const rtCmoOpCode_t type = static_cast<rtCmoOpCode_t>(static_cast<uint32_t>(cmoType) +
1259 : (static_cast<uint32_t>(RT_CMO_PREFETCH) - static_cast<uint32_t>(ACL_RT_CMO_TYPE_PREFETCH)));
1260 2 : ACL_REQUIRES_CALL_RTS_OK(rtCmoAsync(src, size, type, stream), rtCmoAsync);
1261 1 : return ACL_SUCCESS;
1262 : }
1263 :
1264 2 : aclError aclrtGetMemcpyDescSizeImpl(aclrtMemcpyKind kind, size_t *descSize)
1265 : {
1266 2 : ACL_LOG_INFO("start to execute aclrtGetMemcpyDescSize");
1267 2 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(descSize);
1268 2 : ACL_CHECK_LESS_UINT(static_cast<uint32_t>(kind), static_cast<uint32_t>(RT_MEMCPY_KIND_MAX));
1269 2 : const auto rt_mem_kind = static_cast<rtMemcpyKind>(static_cast<uint32_t>(kind));
1270 2 : const auto rtErr = rtsGetMemcpyDescSize(rt_mem_kind, descSize);
1271 2 : if (rtErr != RT_ERROR_NONE) {
1272 1 : ACL_LOG_CALL_ERROR("Get memcpy desc size Failed, runtime result = %d", rtErr);
1273 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1274 : }
1275 1 : return ACL_SUCCESS;
1276 : }
1277 :
1278 6 : aclError aclrtSetMemcpyDescImpl(void *desc, aclrtMemcpyKind kind, void *srcAddr, void *dstAddr, size_t count,
1279 : void *config)
1280 : {
1281 6 : ACL_LOG_INFO("start to execute aclrtSetMemcpyDesc");
1282 6 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(desc);
1283 5 : ACL_CHECK_LESS_UINT(static_cast<uint32_t>(kind), static_cast<uint32_t>(RT_MEMCPY_KIND_MAX));
1284 5 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(srcAddr);
1285 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(dstAddr);
1286 3 : ACL_REQUIRES_POSITIVE_WITH_INPUT_REPORT(count);
1287 2 : if (config != nullptr) {
1288 0 : ACL_LOG_ERROR("[Check][config]param is reserved and only support currently nullptr."); \
1289 0 : return ACL_ERROR_INVALID_PARAM;
1290 : }
1291 :
1292 2 : const auto rt_mem_kind = static_cast<rtMemcpyKind>(static_cast<uint32_t>(kind));
1293 2 : const auto rtErr = rtsSetMemcpyDesc(static_cast<rtMemcpyDesc_t>(desc), rt_mem_kind, srcAddr, dstAddr,
1294 : count, nullptr);
1295 2 : if (rtErr != RT_ERROR_NONE) {
1296 1 : ACL_LOG_CALL_ERROR("Set memcpy desc Failed, runtime result = %d", rtErr);
1297 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1298 : }
1299 1 : return ACL_SUCCESS;
1300 : }
1301 :
1302 4 : aclError aclrtMemcpyAsyncWithDescImpl(void *desc, aclrtMemcpyKind kind, aclrtStream stream)
1303 : {
1304 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpyAsyncWithDesc);
1305 4 : ACL_LOG_INFO("start to execute aclrtMemcpyAsyncWithDesc");
1306 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(desc);
1307 3 : ACL_CHECK_LESS_UINT(static_cast<uint32_t>(kind), static_cast<uint32_t>(RT_MEMCPY_KIND_MAX));
1308 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(stream);
1309 :
1310 2 : const auto rt_mem_kind = static_cast<rtMemcpyKind>(static_cast<int32_t>(kind));
1311 2 : const auto rtErr = rtsMemcpyAsyncWithDesc(static_cast<rtMemcpyDesc_t>(desc), rt_mem_kind, nullptr, stream);
1312 2 : if (rtErr != RT_ERROR_NONE) {
1313 1 : ACL_LOG_CALL_ERROR("Async memcpy with desc Failed, runtime result = %d", rtErr);
1314 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1315 : }
1316 1 : return ACL_SUCCESS;
1317 : }
1318 :
1319 3 : aclError aclrtMemcpyAsyncWithOffsetImpl(void **dst, size_t destMax, size_t dstDataOffset, const void **src,
1320 : size_t count, size_t srcDataOffset, aclrtMemcpyKind kind, aclrtStream stream)
1321 : {
1322 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpyAsyncWithOffset);
1323 3 : ACL_LOG_INFO("start to execute aclrtMemcpyAsyncWithOffset");
1324 3 : const auto memKind = static_cast<rtMemcpyKind>(static_cast<int32_t>(kind));
1325 3 : const auto rtErr = rtMemcpyAsyncWithOffset(dst, destMax, dstDataOffset, src, count, srcDataOffset, memKind, stream);
1326 3 : if (rtErr != RT_ERROR_NONE) {
1327 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
1328 1 : ACL_LOG_WARN("rtMemcpyAsyncWithOffset unsupport, runtime result = %d", static_cast<int32_t>(rtErr));
1329 : } else {
1330 1 : ACL_LOG_CALL_ERROR("call rtMemcpyAsyncWithOffset Failed, runtime result = %d", rtErr);
1331 : }
1332 2 : return ACL_GET_ERRCODE_RTS(rtErr);
1333 : }
1334 1 : ACL_LOG_INFO("successfully execute aclrtMemcpyAsyncWithOffset");
1335 1 : return ACL_SUCCESS;
1336 : }
1337 :
1338 3 : aclError aclrtValueWriteImpl(void* devAddr, uint64_t value, uint32_t flag, aclrtStream stream)
1339 : {
1340 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtValueWrite);
1341 3 : ACL_LOG_INFO("start to execute aclrtValueWrite");
1342 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(devAddr);
1343 :
1344 2 : const auto rtErr = rtsValueWrite(devAddr, value, flag, static_cast<rtStream_t>(stream));
1345 2 : if (rtErr != RT_ERROR_NONE) {
1346 1 : ACL_LOG_CALL_ERROR("call rtsValueWrite Failed, runtime result = %d", rtErr);
1347 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1348 : }
1349 1 : return ACL_SUCCESS;
1350 : }
1351 :
1352 3 : aclError aclrtValueWaitImpl(void* devAddr, uint64_t value, uint32_t flag, aclrtStream stream)
1353 : {
1354 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtValueWait);
1355 3 : ACL_LOG_INFO("start to execute aclrtValueWait");
1356 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(devAddr);
1357 :
1358 2 : const auto rtErr = rtsValueWait(devAddr, value, flag, static_cast<rtStream_t>(stream));
1359 2 : if (rtErr != RT_ERROR_NONE) {
1360 1 : ACL_LOG_CALL_ERROR("call rtsValueWait Failed, runtime result = %d", rtErr);
1361 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1362 : }
1363 1 : return ACL_SUCCESS;
1364 : }
1365 :
1366 14 : aclError aclrtReduceAsyncImpl(void *dst, const void *src, uint64_t count, aclrtReduceKind kind,
1367 : aclDataType type, aclrtStream stream, void *reserve)
1368 : {
1369 28 : ACL_PROFILING_REG(acl::AclProfType::AclrtReduceAsync);
1370 14 : ACL_LOG_DEBUG("start to execute aclrtReduceAsync, count = [%lu], kind = [%u], type = [%u]", count,
1371 : static_cast<uint32_t>(kind), static_cast<uint32_t>(type));
1372 14 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(dst);
1373 13 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(src);
1374 12 : if (reserve != nullptr) {
1375 1 : ACL_LOG_ERROR("[Check][reserve]param must be null.");
1376 1 : acl::AclErrorLogManager::ReportInputError("EH0002", {"param"}, {"reserve"});
1377 1 : return ACL_ERROR_INVALID_PARAM;
1378 : }
1379 :
1380 : rtDataType dataType;
1381 11 : if (kMapDataType.count(type) > 0) {
1382 11 : dataType = kMapDataType.at(type);
1383 : } else {
1384 0 : ACL_LOG_ERROR("[Check][param]param type [%d] is invalid.", static_cast<int32_t>(type));
1385 0 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG, {"param"}, {"type"});
1386 0 : return ACL_ERROR_INVALID_PARAM;
1387 : }
1388 :
1389 11 : rtReduceInfo_t reduceInfo;
1390 11 : reduceInfo.dst = dst;
1391 11 : reduceInfo.src = const_cast<void*>(src);
1392 11 : reduceInfo.count = static_cast<size_t>(count);
1393 11 : reduceInfo.kind = static_cast<rtReduceKind>(kind);
1394 11 : reduceInfo.type = dataType;
1395 11 : const rtError_t rtErr = rtsLaunchReduceAsyncTask(&reduceInfo, static_cast<rtStream_t>(stream), reserve);
1396 11 : if (rtErr != RT_ERROR_NONE) {
1397 1 : ACL_LOG_CALL_ERROR("call rtsLaunchReduceAsyncTask failed, runtime result = %d", rtErr);
1398 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1399 : }
1400 10 : return ACL_SUCCESS;
1401 : }
1402 :
1403 1 : aclError aclrtGetBufFromChainImpl(aclrtMbuf headBuf, uint32_t index, aclrtMbuf *buf)
1404 : {
1405 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetBufFromChain);
1406 1 : ACL_REQUIRES_NOT_NULL(headBuf);
1407 1 : ACL_REQUIRES_NOT_NULL(buf);
1408 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufChainGetMbuf(headBuf, index, buf), rtMbufChainGetMbuf);
1409 1 : return ACL_SUCCESS;
1410 : }
1411 :
1412 1 : aclError aclrtGetBufChainNumImpl(aclrtMbuf headBuf, uint32_t *num)
1413 : {
1414 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetBufChainNum);
1415 1 : ACL_REQUIRES_NOT_NULL(headBuf);
1416 1 : ACL_REQUIRES_NOT_NULL(num);
1417 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufChainGetMbufNum(headBuf, num), rtMbufChainGetMbufNum);
1418 1 : return ACL_SUCCESS;
1419 : }
1420 :
1421 1 : aclError aclrtAppendBufChainImpl(aclrtMbuf headBuf, aclrtMbuf buf)
1422 : {
1423 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtAppendBufChain);
1424 1 : ACL_REQUIRES_NOT_NULL(headBuf);
1425 1 : ACL_REQUIRES_NOT_NULL(buf);
1426 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufChainAppend(headBuf, buf), rtMbufChainAppend);
1427 1 : return ACL_SUCCESS;
1428 : }
1429 :
1430 1 : aclError aclrtCopyBufRefImpl(const aclrtMbuf buf, aclrtMbuf *newBuf)
1431 : {
1432 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtCopyBufRef);
1433 1 : ACL_REQUIRES_NOT_NULL(buf);
1434 1 : ACL_REQUIRES_NOT_NULL(newBuf);
1435 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufCopyBufRef(buf, newBuf), rtMbufCopyBufRef);
1436 1 : return ACL_SUCCESS;
1437 : }
1438 :
1439 1 : aclError aclrtGetBufUserDataImpl(const aclrtMbuf buf, void *dataPtr, size_t size, size_t offset)
1440 : {
1441 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetBufUserData);
1442 : // The current default private data area size is 96B, if offset+size exceeds 96, an error is reported
1443 1 : ACL_CHECK_LESS_UINT((size + offset), MEM_SIZE_MAX);
1444 1 : ACL_REQUIRES_NOT_NULL(buf);
1445 1 : ACL_REQUIRES_NOT_NULL(dataPtr);
1446 1 : uint64_t bufSize = 0U;
1447 1 : void *tmpDataPtr = nullptr;
1448 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufGetPrivInfo(buf, &tmpDataPtr, &bufSize), rtMbufGetPrivInfo);
1449 1 : ACL_CHECK_LESS_UINT(size, static_cast<size_t>(bufSize));
1450 1 : ACL_REQUIRES_NOT_NULL(tmpDataPtr);
1451 1 : const auto ret = memcpy_s(dataPtr, size, (static_cast<uint8_t *>(tmpDataPtr) + offset), size);
1452 1 : if (ret != EOK) {
1453 0 : ACL_LOG_INNER_ERROR("call memcpy_s failed, result = %d, size = %zu, bufSize = %lu, offset = %zu",
1454 : ret, size, bufSize, offset);
1455 0 : return ACL_ERROR_FAILURE;
1456 : }
1457 1 : return ACL_SUCCESS;
1458 : }
1459 :
1460 1 : aclError aclrtSetBufUserDataImpl(aclrtMbuf buf, const void *dataPtr, size_t size, size_t offset)
1461 : {
1462 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtSetBufUserData);
1463 : // The current default private data area size is 96B, if offset+size exceeds 96, an error is reported
1464 1 : ACL_CHECK_LESS_UINT((size + offset), MEM_SIZE_MAX);
1465 1 : ACL_REQUIRES_NOT_NULL(buf);
1466 1 : ACL_REQUIRES_NOT_NULL(dataPtr);
1467 1 : uint64_t bufSize = 0U;
1468 1 : void *tmpDataPtr = nullptr;
1469 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufGetPrivInfo(buf, &tmpDataPtr, &bufSize), rtMbufGetPrivInfo);
1470 1 : ACL_CHECK_LESS_UINT(size, static_cast<size_t>(bufSize));
1471 1 : ACL_REQUIRES_NOT_NULL(tmpDataPtr);
1472 1 : const auto ret = memcpy_s((static_cast<uint8_t *>(tmpDataPtr) + offset),
1473 : (static_cast<size_t>(bufSize) - offset),
1474 : dataPtr, size);
1475 1 : if (ret != EOK) {
1476 0 : ACL_LOG_INNER_ERROR("call memcpy_s failed, result = %d, size = %zu, bufSize = %lu, offset = %zu",
1477 : ret, size, bufSize, offset);
1478 0 : return ACL_ERROR_FAILURE;
1479 : }
1480 1 : return ACL_SUCCESS;
1481 : }
1482 :
1483 4 : aclError aclrtGetBufDataImpl(const aclrtMbuf buf, void **dataPtr, size_t *size)
1484 : {
1485 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetBufData);
1486 4 : ACL_REQUIRES_NOT_NULL(buf);
1487 1 : ACL_REQUIRES_NOT_NULL(dataPtr);
1488 1 : ACL_REQUIRES_NOT_NULL(size);
1489 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufGetBuffAddr(buf, dataPtr), rtMbufGetBuffAddr);
1490 1 : uint64_t bufSize = 0U;
1491 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufGetBuffSize(buf, &bufSize), rtMbufGetBuffSize);
1492 1 : *size = static_cast<size_t>(bufSize);
1493 1 : return ACL_SUCCESS;
1494 : }
1495 :
1496 1 : aclError aclrtGetBufDataLenImpl(aclrtMbuf buf, size_t *len)
1497 : {
1498 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtGetBufDataLen);
1499 1 : ACL_REQUIRES_NOT_NULL(buf);
1500 1 : ACL_REQUIRES_NOT_NULL(len);
1501 1 : uint64_t dataLen = 0U;
1502 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufGetDataLen(buf, &dataLen), rtMbufGetDataLen);
1503 1 : *len = static_cast<size_t>(dataLen);
1504 1 : return ACL_SUCCESS;
1505 : }
1506 :
1507 1 : aclError aclrtSetBufDataLenImpl(aclrtMbuf buf, size_t len)
1508 : {
1509 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtSetBufDataLen);
1510 1 : ACL_REQUIRES_NOT_NULL(buf);
1511 1 : ACL_REQUIRES_CALL_RTS_OK(rtMbufSetDataLen(buf, len), rtMbufSetDataLen);
1512 1 : return ACL_SUCCESS;
1513 : }
1514 :
1515 8 : aclError aclrtFreeBufImpl(aclrtMbuf buf)
1516 : {
1517 16 : ACL_PROFILING_REG(acl::AclProfType::AclrtFreeBuf);
1518 8 : ACL_REQUIRES_NOT_NULL(buf);
1519 8 : const rtError_t rtRet = rtMbufFree(buf);
1520 8 : if (rtRet != RT_ERROR_NONE) {
1521 0 : ACL_LOG_CALL_ERROR("[Free][buf]fail to call rtMbufFree, result is [%d]", rtRet);
1522 0 : return rtRet;
1523 : }
1524 8 : buf = nullptr;
1525 8 : return ACL_SUCCESS;
1526 : }
1527 :
1528 4 : aclError aclrtAllocBufImpl(aclrtMbuf *buf, size_t size)
1529 : {
1530 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtAllocBuf);
1531 4 : ACL_LOG_INFO("start to execute aclrtAllocBuf, size is [%zu]", size);
1532 4 : ACL_REQUIRES_NOT_NULL(buf);
1533 : // size must be greater than zero
1534 3 : if (size == 0UL) {
1535 1 : ACL_LOG_ERROR("malloc size must be greater than zero");
1536 3 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
1537 2 : std::vector<const char *>({"param", "value", "reason"}),
1538 2 : std::vector<const char *>({"size", std::to_string(size).c_str(), "size must be greater than zero"}));
1539 1 : return ACL_ERROR_INVALID_PARAM;
1540 : }
1541 2 : const rtError_t rtRet = rtMbufAlloc(buf, size);
1542 2 : if (rtRet != RT_ERROR_NONE) {
1543 1 : ACL_LOG_CALL_ERROR("[Alloc][buf]fail to call rtMbufAlloc, result is [%d]", rtRet);
1544 1 : return rtRet;
1545 : }
1546 1 : return ACL_SUCCESS;
1547 : }
1548 :
1549 3 : aclError aclrtCmoAsyncWithBarrierImpl(void *src, size_t size, aclrtCmoType cmoType, uint32_t barrierId,
1550 : aclrtStream stream)
1551 : {
1552 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtCmoAsyncWithBarrier);
1553 3 : ACL_LOG_INFO("start to execute aclrtCmoAsyncWithBarrier, size is [%zu], cmoType is [%u], barrierId is [%u]",
1554 : size, static_cast<uint32_t>(cmoType), barrierId);
1555 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(src);
1556 2 : const rtCmoOpCode rtCmoType = static_cast<rtCmoOpCode>(static_cast<uint32_t>(cmoType) +
1557 : (static_cast<uint32_t>(RT_CMO_PREFETCH) - static_cast<uint32_t>(ACL_RT_CMO_TYPE_PREFETCH)));
1558 2 : const auto rtErr = rtsCmoAsyncWithBarrier(src, size, rtCmoType, barrierId, static_cast<rtStream_t>(stream));
1559 2 : if (rtErr != RT_ERROR_NONE) {
1560 1 : ACL_LOG_CALL_ERROR("call rtsCmoAsyncWithBarrier Failed, runtime result = %d", rtErr);
1561 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1562 : }
1563 1 : return ACL_SUCCESS;
1564 : }
1565 :
1566 24 : static aclError MemcpyBatchImpl(void **dsts, size_t *destMaxs, void **srcs, size_t *sizes, size_t numBatches,
1567 : aclrtMemcpyBatchAttr *attrs, size_t *attrsIndexes, size_t numAttrs, size_t *failIndex,
1568 : aclrtStream stream, bool async)
1569 : {
1570 24 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(dsts);
1571 22 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(destMaxs);
1572 20 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(srcs);
1573 18 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(sizes);
1574 16 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(attrs);
1575 14 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(attrsIndexes);
1576 12 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(failIndex);
1577 :
1578 10 : if (numBatches == 0UL) {
1579 2 : ACL_LOG_ERROR("param numBatches must be greater than zero");
1580 6 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
1581 4 : std::vector<const char *>({"param", "value", "reason"}),
1582 4 : std::vector<const char *>({"numBatches", std::to_string(numBatches).c_str(),
1583 : "numBatches must be greater than zero"}));
1584 2 : return ACL_ERROR_INVALID_PARAM;
1585 : }
1586 :
1587 55 : for (size_t i = 0UL; i < numBatches; i++) {
1588 49 : if (destMaxs[i] < sizes[i]) {
1589 2 : ACL_LOG_ERROR("element of destMaxs must be equal to or greater than corresponding element of sizes");
1590 6 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
1591 4 : std::vector<const char *>({"param", "value", "reason"}),
1592 4 : std::vector<const char *>({"destMaxs", std::to_string(destMaxs[i]).c_str(),
1593 : "element of destMaxs must be equal to or greater than corresponding element of sizes"}));
1594 2 : return ACL_ERROR_INVALID_PARAM;
1595 : }
1596 : }
1597 :
1598 6 : constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
1599 10 : for (size_t idx = 0UL; idx < numAttrs; idx++) {
1600 70 : for (uint32_t i = 0U; i < rsvMaxSize; i++) {
1601 66 : if (attrs[idx].rsv[i] != 0U) {
1602 2 : ACL_LOG_ERROR("rsv field of attrs[%zu] must be zero", idx);
1603 2 : return ACL_ERROR_INVALID_PARAM;
1604 : }
1605 : }
1606 : }
1607 :
1608 4 : if (async) {
1609 2 : const auto rtErr = rtsMemcpyBatchAsync(dsts, destMaxs, srcs, sizes, numBatches, reinterpret_cast<rtMemcpyBatchAttr*>(attrs),
1610 : attrsIndexes, numAttrs, failIndex, stream);
1611 2 : if (rtErr != RT_ERROR_NONE) {
1612 1 : ACL_LOG_CALL_ERROR("call rtsMemcpyBatchAsync failed, runtime result = %d.", static_cast<int32_t>(rtErr));
1613 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1614 : }
1615 1 : ACL_LOG_INFO("successfully execute aclrtMemcpyBatchAsync");
1616 : } else {
1617 2 : const auto rtErr = rtsMemcpyBatch(dsts, srcs, sizes, numBatches, reinterpret_cast<rtMemcpyBatchAttr*>(attrs),
1618 : attrsIndexes, numAttrs, failIndex);
1619 2 : if (rtErr != RT_ERROR_NONE) {
1620 1 : ACL_LOG_CALL_ERROR("call rtsMemcpyBatch failed, runtime result = %d.", static_cast<int32_t>(rtErr));
1621 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1622 : }
1623 1 : ACL_LOG_INFO("successfully execute aclrtMemcpyBatch");
1624 : }
1625 :
1626 2 : return ACL_SUCCESS;
1627 : }
1628 :
1629 4 : aclError aclrtIpcMemGetExportKeyImpl(void *devPtr, size_t size, char *key, size_t len, uint64_t flags)
1630 : {
1631 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtIpcMemGetExportKey);
1632 4 : ACL_LOG_INFO("start to execute aclrtIpcMemGetExportKey, size is [%zu], len is [%zu], flags is [%lu]",
1633 : size, len, flags);
1634 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(devPtr);
1635 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(key);
1636 2 : const auto rtErr = rtsIpcMemGetExportKey(devPtr, size, key, static_cast<uint32_t>(len), flags);
1637 2 : if (rtErr != RT_ERROR_NONE) {
1638 1 : ACL_LOG_CALL_ERROR("call rtsIpcMemGetExportKey failed, runtime result = %d", rtErr);
1639 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1640 : }
1641 1 : return ACL_SUCCESS;
1642 : }
1643 :
1644 3 : aclError aclrtIpcMemCloseImpl(const char *key)
1645 : {
1646 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtIpcMemClose);
1647 3 : ACL_LOG_INFO("start to execute aclrtIpcMemClose");
1648 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(key);
1649 2 : const auto rtErr = rtsIpcMemClose(key);
1650 2 : if (rtErr != RT_ERROR_NONE) {
1651 1 : ACL_LOG_CALL_ERROR("call rtsIpcMemClose failed, runtime result = %d", rtErr);
1652 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1653 : }
1654 1 : return ACL_SUCCESS;
1655 : }
1656 :
1657 4 : aclError aclrtIpcMemImportByKeyImpl(void **devPtr, const char *key, uint64_t flags)
1658 : {
1659 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtIpcMemImportByKey);
1660 4 : ACL_LOG_INFO("start to execute aclrtIpcMemImportByKey, flags is [%lu]", flags);
1661 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(devPtr);
1662 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(key);
1663 2 : const auto rtErr = rtsIpcMemImportByKey(devPtr, key, flags);
1664 2 : if (rtErr != RT_ERROR_NONE) {
1665 1 : ACL_LOG_CALL_ERROR("call rtsIpcMemImportByKey failed, runtime result = %d", rtErr);
1666 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1667 : }
1668 1 : return ACL_SUCCESS;
1669 : }
1670 :
1671 12 : aclError aclrtMemcpyBatchImpl(void **dsts, size_t *destMaxs, void **srcs, size_t *sizes, size_t numBatches,
1672 : aclrtMemcpyBatchAttr *attrs, size_t *attrsIndexes, size_t numAttrs, size_t *failIndex)
1673 : {
1674 24 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpyBatch);
1675 12 : ACL_LOG_INFO("start to execute aclrtMemcpyBatch");
1676 12 : return MemcpyBatchImpl(dsts, destMaxs, srcs, sizes, numBatches, attrs, attrsIndexes, numAttrs, failIndex,
1677 24 : nullptr, false);
1678 : }
1679 :
1680 12 : aclError aclrtMemcpyBatchAsyncImpl(void **dsts, size_t *destMaxs, void **srcs, size_t *sizes,
1681 : size_t numBatches, aclrtMemcpyBatchAttr *attrs, size_t *attrsIndexes, size_t numAttrs, size_t *failIndex,
1682 : aclrtStream stream)
1683 : {
1684 24 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemcpyBatchAsync);
1685 12 : ACL_LOG_INFO("start to execute aclrtMemcpyBatchAsync");
1686 12 : return MemcpyBatchImpl(dsts, destMaxs, srcs, sizes, numBatches, attrs, attrsIndexes, numAttrs, failIndex,
1687 24 : stream, true);
1688 : }
1689 :
1690 4 : aclError aclrtIpcMemSetImportPidImpl(const char *key, int32_t *pid, size_t num)
1691 : {
1692 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtIpcMemSetImportPid);
1693 4 : ACL_LOG_INFO("start to execute aclrtIpcMemSetImportPid, num is [%zu]", num);
1694 4 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(key);
1695 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(pid);
1696 2 : const auto rtErr = rtsIpcMemSetImportPid(key, pid, static_cast<int32_t>(num));
1697 2 : if (rtErr != RT_ERROR_NONE) {
1698 1 : ACL_LOG_CALL_ERROR("call rtsIpcMemSetImportPid failed, runtime result = %d", rtErr);
1699 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1700 : }
1701 1 : return ACL_SUCCESS;
1702 : }
1703 :
1704 2 : aclError aclrtIpcMemSetAttrImpl(const char *key, aclrtIpcMemAttrType type, uint64_t attr)
1705 : {
1706 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtIpcMemSetAttr);
1707 2 : ACL_LOG_INFO("start to execute aclrtIpcMemSetAttr, type is [%d], attr is [%lu]", type, attr);
1708 2 : const auto rtErr = rtIpcSetMemoryAttr(key, type, attr);
1709 2 : if (rtErr != RT_ERROR_NONE) {
1710 1 : ACL_LOG_CALL_ERROR("call rtIpcSetMemoryAttr failed, runtime result = %d", rtErr);
1711 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1712 : }
1713 1 : ACL_LOG_INFO("successfully execute aclrtIpcMemSetAttr");
1714 1 : return ACL_SUCCESS;
1715 : }
1716 :
1717 2 : aclError aclrtIpcMemImportPidInterServerImpl(const char *key, aclrtServerPid *serverPids, size_t num)
1718 : {
1719 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtIpcMemImportPidInterServer);
1720 2 : ACL_LOG_INFO("start to execute aclrtIpcMemImportPidInterServer, num is [%zu]", num);
1721 2 : const auto rtErr = rtIpcMemImportPidInterServer(key, reinterpret_cast<const rtServerPid *>(serverPids), num);
1722 2 : if (rtErr != RT_ERROR_NONE) {
1723 1 : ACL_LOG_CALL_ERROR("call aclrtIpcMemImportPidInterServer failed, runtime result = %d", rtErr);
1724 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1725 : }
1726 1 : ACL_LOG_INFO("successfully execute aclrtIpcMemImportPidInterServer");
1727 1 : return ACL_SUCCESS;
1728 : }
1729 :
1730 1 : aclError aclrtCheckMemTypeImpl(void** addrList, uint32_t size, uint32_t memType, uint32_t *checkResult, uint32_t reserve)
1731 : {
1732 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtCheckMemType);
1733 1 : ACL_LOG_INFO("start to execute AclrtCheckMemType, size is [%u], memType is [%u], reserve is [%u]", size, memType, reserve);
1734 1 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(addrList);
1735 1 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(checkResult);
1736 1 : const auto rtErr = rtsCheckMemType(addrList, size, memType, checkResult, reserve);
1737 1 : if (rtErr != RT_ERROR_NONE) {
1738 0 : ACL_LOG_CALL_ERROR("call rtsCheckMemType failed, runtime result = %d", rtErr);
1739 0 : return ACL_GET_ERRCODE_RTS(rtErr);
1740 : }
1741 1 : return ACL_SUCCESS;
1742 : }
1743 :
1744 3 : aclError aclrtDevicePeerAccessStatusImpl(int32_t deviceId, int32_t peerDeviceId, int32_t *status)
1745 : {
1746 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtDevicePeerAccessStatus);
1747 3 : ACL_LOG_INFO("start to execute aclrtDevicePeerAccessStatus");
1748 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(status);
1749 2 : const rtError_t rtErr = rtsGetP2PStatus(
1750 : static_cast<uint32_t>(deviceId), static_cast<uint32_t>(peerDeviceId), reinterpret_cast<uint32_t *>(status));
1751 2 : if (rtErr != RT_ERROR_NONE) {
1752 1 : ACL_LOG_CALL_ERROR("call rtsGetP2PStatus failed, runtime result = %d.", static_cast<int32_t>(rtErr));
1753 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1754 : }
1755 1 : ACL_LOG_INFO("successfully execute aclrtDevicePeerAccessStatus");
1756 1 : return ACL_SUCCESS;
1757 : }
1758 :
1759 2 : aclError aclrtCmoGetDescSizeImpl(size_t *size)
1760 : {
1761 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtCmoGetDescSize);
1762 2 : ACL_LOG_DEBUG("start to execute aclrtCmoGetDescSize");
1763 2 : const rtError_t rtErr = rtsGetCmoDescSize(size);
1764 2 : if (rtErr != RT_ERROR_NONE) {
1765 1 : ACL_LOG_CALL_ERROR("call rtsGetCmoDescSize failed, runtime result = %d", rtErr);
1766 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1767 : }
1768 1 : ACL_LOG_INFO("successfully execute aclrtCmoGetDescSize");
1769 1 : return ACL_SUCCESS;
1770 : }
1771 :
1772 2 : aclError aclrtCmoSetDescImpl(void *cmoDesc, void *src, size_t size)
1773 : {
1774 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtCmoSetDesc);
1775 2 : ACL_LOG_DEBUG("start to execute aclrtCmoSetDesc, memLen =%zu", size);
1776 2 : const rtError_t rtErr = rtsSetCmoDesc(cmoDesc, src, size);
1777 2 : if (rtErr != RT_ERROR_NONE) {
1778 1 : ACL_LOG_CALL_ERROR("call rtsSetCmoDesc failed, runtime result = %d", rtErr);
1779 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1780 : }
1781 1 : ACL_LOG_INFO("successfully execute aclrtCmoSetDesc");
1782 1 : return ACL_SUCCESS;
1783 : }
1784 :
1785 2 : static rtCmoOpCode ConvertCmoType(aclrtCmoType cmoType)
1786 : {
1787 2 : constexpr uint32_t offset =
1788 : static_cast<uint32_t>(RT_CMO_PREFETCH) - static_cast<uint32_t>(ACL_RT_CMO_TYPE_PREFETCH);
1789 2 : return static_cast<rtCmoOpCode>(static_cast<uint32_t>(cmoType) + offset);
1790 : }
1791 :
1792 2 : aclError aclrtCmoAsyncWithDescImpl(void *cmoDesc, aclrtCmoType cmoType, aclrtStream stream, const void *reserve)
1793 : {
1794 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtCmoAsyncWithDesc);
1795 2 : ACL_LOG_DEBUG("start to execute aclrtCmoAsyncWithDesc");
1796 2 : const rtCmoOpCode rtCmoType = ConvertCmoType(cmoType);
1797 2 : const rtError_t rtErr = rtsLaunchCmoAddrTask(cmoDesc, stream, rtCmoType, reserve);
1798 2 : if (rtErr != RT_ERROR_NONE) {
1799 1 : ACL_LOG_CALL_ERROR("call rtsLaunchCmoAddrTask failed, runtime result = %d", rtErr);
1800 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1801 : }
1802 1 : ACL_LOG_INFO("successfully execute aclrtCmoAsyncWithDesc");
1803 1 : return ACL_SUCCESS;
1804 : }
1805 :
1806 4 : aclError aclrtMemSetAccessImpl(void *virPtr, size_t size, aclrtMemAccessDesc *desc, size_t count)
1807 : {
1808 8 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemSetAccess);
1809 4 : ACL_LOG_INFO("start to execute aclrtMemSetAccess");
1810 :
1811 4 : const rtError_t rtErr = rtMemSetAccess(virPtr, size, reinterpret_cast<rtMemAccessDesc*>(desc), count);
1812 4 : if (rtErr != RT_ERROR_NONE) {
1813 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
1814 1 : ACL_LOG_WARN("call aclrtMemSetAccess failed, runtime result = %d.", static_cast<int32_t>(rtErr));
1815 : } else {
1816 1 : ACL_LOG_CALL_ERROR("call aclrtMemSetAccess failed, runtime result = %d.", static_cast<int32_t>(rtErr));
1817 : }
1818 2 : return ACL_GET_ERRCODE_RTS(rtErr);
1819 : }
1820 2 : ACL_LOG_INFO("successfully execute aclrtMemSetAccess");
1821 2 : return ACL_SUCCESS;
1822 : }
1823 :
1824 3 : aclError aclrtMemRetainAllocationHandleImpl(void* virPtr, aclrtDrvMemHandle *handle)
1825 : {
1826 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemRetainAllocationHandle);
1827 3 : ACL_LOG_DEBUG("start to execute aclrtMemRetainAllocationHandle");
1828 3 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(virPtr);
1829 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
1830 :
1831 2 : const rtError_t rtErr = rtMemRetainAllocationHandle(virPtr, reinterpret_cast<rtDrvMemHandle*>(handle));
1832 2 : if (rtErr != ACL_RT_SUCCESS) {
1833 1 : ACL_LOG_CALL_ERROR("get handle failed, runtime result = %d", static_cast<int32_t>(rtErr));
1834 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1835 : }
1836 1 : return ACL_SUCCESS;
1837 : }
1838 :
1839 : //initialize the mapping table
1840 : static const MemAttrMapping mapping[] {
1841 : {HUGE_PAGE_TYPE, HBM_TYPE, true, ACL_HBM_MEM_HUGE},
1842 : {NORMAL_PAGE_TYPE, HBM_TYPE, true, ACL_HBM_MEM_NORMAL},
1843 : {HUGE1G_PAGE_TYPE, HBM_TYPE, true, ACL_HBM_MEM_HUGE1G},
1844 : {NORMAL_PAGE_TYPE, P2P_DDR_TYPE, true, ACL_DDR_MEM_P2P_NORMAL},
1845 : {NORMAL_PAGE_TYPE, DDR_TYPE, true, ACL_MEM_NORMAL},
1846 : {HUGE_PAGE_TYPE, DDR_TYPE, true, ACL_MEM_HUGE},
1847 : {HUGE1G_PAGE_TYPE, DDR_TYPE, true, ACL_MEM_HUGE1G},
1848 : {HUGE_PAGE_TYPE, P2P_DDR_TYPE, true, ACL_MEM_P2P_HUGE},
1849 : {HUGE1G_PAGE_TYPE, P2P_DDR_TYPE, true, ACL_MEM_P2P_HUGE1G},
1850 : {NORMAL_PAGE_TYPE, HBM_TYPE, false, ACL_HBM_MEM_NORMAL},
1851 : {HUGE_PAGE_TYPE, HBM_TYPE, false, ACL_HBM_MEM_HUGE},
1852 : {HUGE1G_PAGE_TYPE, HBM_TYPE, false, ACL_HBM_MEM_HUGE1G},
1853 : {NORMAL_PAGE_TYPE, DDR_TYPE, false, ACL_MEM_NORMAL},
1854 : {HUGE_PAGE_TYPE, DDR_TYPE, false, ACL_MEM_HUGE},
1855 : {HUGE1G_PAGE_TYPE, DDR_TYPE, false, ACL_MEM_HUGE1G},
1856 : {NORMAL_PAGE_TYPE, P2P_HBM_TYPE, false, ACL_MEM_P2P_NORMAL},
1857 : {HUGE_PAGE_TYPE, P2P_HBM_TYPE, false, ACL_MEM_P2P_HUGE},
1858 : {HUGE1G_PAGE_TYPE, P2P_HBM_TYPE, false, ACL_MEM_P2P_HUGE1G}
1859 : };
1860 :
1861 5 : aclError aclrtMemGetAllocationPropertiesFromHandleImpl(aclrtDrvMemHandle handle, aclrtPhysicalMemProp* prop)
1862 : {
1863 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemGetAllocationPropertiesFromHandle);
1864 5 : ACL_LOG_DEBUG("start to execute AclrtMemGetAllocationPropertiesFromHandle");
1865 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(handle);
1866 4 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(prop);
1867 :
1868 4 : rtDrvMemProp_t rtProp = {};
1869 4 : const rtError_t rtErr = rtMemGetAllocationPropertiesFromHandle(reinterpret_cast<rtDrvMemHandle>(handle), &rtProp);
1870 4 : if (rtErr != ACL_RT_SUCCESS) {
1871 1 : ACL_LOG_CALL_ERROR("get handle failed, runtime result = %d", static_cast<int32_t>(rtErr));
1872 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1873 : }
1874 :
1875 3 : prop->handleType = ACL_MEM_HANDLE_TYPE_NONE;
1876 3 : prop->allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
1877 3 : if (rtProp.side == DRV_MEM_HOST_NUMA_SIDE) {
1878 : // convert drv side to acl locationtype
1879 0 : prop->location.type = ACL_MEM_LOCATION_TYPE_HOST_NUMA;
1880 : } else {
1881 3 : prop->location.type = static_cast<aclrtMemLocationType>(rtProp.side);
1882 : }
1883 3 : prop->location.id = rtProp.devid;
1884 3 : prop->reserve = rtProp.reserve;
1885 :
1886 : //host alloc
1887 3 : bool isHostAlloc = (prop->location.type == ACL_MEM_LOCATION_TYPE_HOST) || (prop->location.type == ACL_MEM_LOCATION_TYPE_HOST_NUMA);
1888 :
1889 3 : const auto& it = std::find_if(std::begin(mapping), std::end(mapping),
1890 9 : [rtProp, isHostAlloc](const MemAttrMapping& entry) {
1891 9 : return (entry.pgType == rtProp.pg_type) &&
1892 9 : (entry.memType == rtProp.mem_type) &&
1893 9 : (entry.isHostAlloc == isHostAlloc);
1894 3 : });
1895 3 : if (it != std::end(mapping)) {
1896 3 : prop->memAttr = it->memAttr;
1897 : } else {
1898 0 : ACL_LOG_ERROR("memAttr not found for pg_type=%u, mem_type=%u, isHostAlloc=%u",
1899 : rtProp.pg_type, rtProp.mem_type, isHostAlloc);
1900 0 : return ACL_ERROR_INVALID_PARAM;
1901 : }
1902 3 : return ACL_SUCCESS;
1903 : }
1904 :
1905 5 : aclError aclrtReserveMemAddressNoUCMemoryImpl(void **virPtr, size_t size, size_t alignment, void *expectPtr, uint64_t flags)
1906 : {
1907 10 : ACL_PROFILING_REG(acl::AclProfType::AclrtReserveMemAddressNoUCMemory);
1908 5 : ACL_LOG_DEBUG("start to execute aclrtReserveMemAddressNoUCMemory, size = %zu", size);
1909 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(virPtr);
1910 :
1911 5 : if (size == 0UL) {
1912 1 : ACL_LOG_ERROR("size is [%zu], reserve size must be greater than zero", size);
1913 3 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
1914 2 : std::vector<const char *>({"param", "value", "reason"}),
1915 2 : std::vector<const char *>({"size", std::to_string(size).c_str(), "reserve size must be greater than zero"}));
1916 1 : return ACL_ERROR_INVALID_PARAM;
1917 : }
1918 4 : if ((flags != 1ULL) && (flags != 0ULL)) {
1919 1 : ACL_LOG_ERROR("flags is [%lu], flags of page type must be 0 or 1", flags);
1920 3 : acl::AclErrorLogManager::ReportInputError(acl::INVALID_PARAM_MSG,
1921 2 : std::vector<const char *>({"param", "value", "reason"}),
1922 2 : std::vector<const char *>({"flags", std::to_string(flags).c_str(), "flags of page type must be 0 or 1"}));
1923 1 : return ACL_ERROR_INVALID_PARAM;
1924 : }
1925 :
1926 3 : flags = flags | FLAG_START_DYNAMIC_ALLOC_MEM; // bit 9置1
1927 3 : const rtError_t rtErr = rtReserveMemAddress(virPtr, size, alignment, expectPtr, flags);
1928 3 : if (rtErr != RT_ERROR_NONE) {
1929 2 : if (rtErr == ACL_ERROR_RT_FEATURE_NOT_SUPPORT) {
1930 1 : ACL_LOG_WARN("reserve memory address without UCMemeory unsupport, runtime result = %d", static_cast<int32_t>(rtErr));
1931 : } else {
1932 1 : ACL_LOG_CALL_ERROR("reserve memory address without UCMemeory failed, runtime result = %d", static_cast<int32_t>(rtErr));
1933 : }
1934 2 : return ACL_GET_ERRCODE_RTS(rtErr);
1935 : }
1936 1 : return ACL_SUCCESS;
1937 : }
1938 :
1939 2 : aclError aclrtMemGetAddressRangeImpl(void *ptr, void **pbase, size_t *psize)
1940 : {
1941 4 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemGetAddressRange);
1942 2 : ACL_LOG_DEBUG("start to execute aclrtMemGetAddressRange");
1943 2 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(ptr);
1944 1 : const rtError_t rtErr = rtMemGetAddressRange(ptr, pbase, psize);
1945 1 : if (rtErr != RT_ERROR_NONE) {
1946 0 : ACL_LOG_CALL_ERROR("call aclrtMemGetAddressRange failed, runtime result = %d.", static_cast<int32_t>(rtErr));
1947 0 : return ACL_GET_ERRCODE_RTS(rtErr);
1948 : }
1949 1 : ACL_LOG_INFO("successfully execute aclrtMemGetAddressRange");
1950 1 : return ACL_SUCCESS;
1951 : }
1952 :
1953 5 : aclError aclrtMemP2PMapImpl(void *devPtr, size_t size, int32_t dstDevId, uint64_t flags)
1954 : {
1955 10 : ACL_PROFILING_REG(acl::AclProfType::aclrtMemP2PMap);
1956 5 : ACL_LOG_INFO("start to execute aclrtMemP2PMap");
1957 5 : ACL_REQUIRES_NOT_NULL_WITH_INPUT_REPORT(devPtr);
1958 4 : ACL_REQUIRES_TRUE(size > 0UL, ACL_ERROR_INVALID_PARAM, "size in aclrtMemP2PMap must be large than 0 !");
1959 3 : ACL_REQUIRES_TRUE(flags == 0UL, ACL_ERROR_INVALID_PARAM, "flags in aclrtMemP2PMap must be 0 !");
1960 2 : uint32_t phyId = 0U;
1961 2 : rtError_t rtErr = rtGetDevicePhyIdByIndex(static_cast<uint32_t>(dstDevId), &phyId);
1962 2 : if (rtErr != RT_ERROR_NONE) {
1963 1 : ACL_LOG_CALL_ERROR("call rtGetDevicePhyIdByIndex failed, dstDevId = %u, runtime result = %d",
1964 : dstDevId, static_cast<int32_t>(rtErr));
1965 1 : return ACL_GET_ERRCODE_RTS(rtErr);
1966 : }
1967 1 : rtErr = rtMemPrefetchToDevice(devPtr, size, phyId);
1968 1 : if (rtErr != RT_ERROR_NONE) {
1969 0 : ACL_LOG_CALL_ERROR("call aclrtMemP2PMap failed, runtime result = %d.", static_cast<int32_t>(rtErr));
1970 0 : return ACL_GET_ERRCODE_RTS(rtErr);
1971 : }
1972 1 : ACL_LOG_INFO("successfully execute aclrtMemP2PMap");
1973 1 : return ACL_SUCCESS;
1974 : }
1975 :
1976 3 : aclError aclrtMemPoolCreateImpl(aclrtMemPool *memPool, const aclrtMemPoolProps *poolProps)
1977 : {
1978 6 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemPoolCreate);
1979 3 : ACL_LOG_INFO("start to execute aclrtMemPoolCreate.");
1980 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(memPool);
1981 3 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(poolProps);
1982 :
1983 3 : if (poolProps->allocType != aclrtMemAllocationType::ACL_MEM_ALLOCATION_TYPE_PINNED) {
1984 0 : ACL_LOG_ERROR("[Check]param:poolProp.allocType must be ACL_MEM_ALLOCATION_TYPE_PINNED, but got: %d.",
1985 : poolProps->allocType);
1986 0 : return ACL_ERROR_INVALID_PARAM;
1987 : }
1988 :
1989 3 : if (poolProps->location.type != aclrtMemLocationType::ACL_MEM_LOCATION_TYPE_DEVICE) {
1990 1 : ACL_LOG_ERROR("[Check]param:poolProp.location.type must be ACL_MEM_LOCATION_TYPE_DEVICE, but got: %d.",
1991 : poolProps->location.type);
1992 1 : return ACL_ERROR_INVALID_PARAM;
1993 : }
1994 :
1995 2 : rtMemPoolProps rtPoolProps;
1996 2 : rtPoolProps.side = ACL_MEM_LOCATION_TYPE_DEVICE;
1997 2 : rtPoolProps.devId = poolProps->location.id;
1998 2 : rtPoolProps.handleType = static_cast<rtDrvMemHandleType>(poolProps->handleType);
1999 2 : rtPoolProps.maxSize = poolProps->maxSize;
2000 2 : rtPoolProps.reserve = 0;
2001 :
2002 2 : uint8_t zeros[sizeof(poolProps->reserved)] = {0};
2003 2 : if (memcmp(poolProps->reserved, zeros, sizeof(poolProps->reserved)) != 0) {
2004 1 : ACL_LOG_CALL_ERROR("poolProps reserve invaild.");
2005 1 : return ACL_ERROR_INVALID_PARAM;
2006 : }
2007 :
2008 1 : const auto rtErr = rtMemPoolCreate(reinterpret_cast<rtMemPool_t*>(memPool), &rtPoolProps);
2009 1 : if (rtErr != RT_ERROR_NONE) {
2010 0 : ACL_LOG_CALL_ERROR("call rtMemPoolCreate failed, runtime result = %d.", rtErr);
2011 0 : return ACL_GET_ERRCODE_RTS(rtErr);
2012 : }
2013 1 : return ACL_SUCCESS;
2014 : }
2015 :
2016 1 : aclError aclrtMemPoolDestroyImpl(const aclrtMemPool memPool)
2017 : {
2018 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemPoolDestroy);
2019 1 : ACL_LOG_INFO("start to execute aclrtMemPoolDestroy.");
2020 1 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(memPool);
2021 :
2022 1 : const auto rtErr = rtMemPoolDestroy(static_cast<rtMemPool_t>(memPool));
2023 1 : if (rtErr != RT_ERROR_NONE) {
2024 0 : ACL_LOG_CALL_ERROR("call rtMemPoolDestroy failed, runtime result = %d.", rtErr);
2025 0 : return ACL_GET_ERRCODE_RTS(rtErr);
2026 : }
2027 1 : return ACL_SUCCESS;
2028 : }
2029 :
2030 1 : aclError aclrtMemPoolSetAttrImpl(aclrtMemPool memPool, aclrtMemPoolAttr attr, void *value)
2031 : {
2032 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemPoolSetAttr);
2033 1 : ACL_LOG_INFO("start to execute aclrtMemPoolSetAttr.");
2034 1 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(memPool);
2035 :
2036 1 : const auto rtErr = rtMemPoolSetAttr(static_cast<rtMemPool_t>(memPool), static_cast<rtMemPoolAttr>(attr), value);
2037 1 : if (rtErr != RT_ERROR_NONE) {
2038 0 : ACL_LOG_CALL_ERROR("call rtMemPoolSetAttr failed, runtime result = %d.", rtErr);
2039 0 : return ACL_GET_ERRCODE_RTS(rtErr);
2040 : }
2041 1 : return ACL_SUCCESS;
2042 : }
2043 :
2044 1 : aclError aclrtMemPoolGetAttrImpl(aclrtMemPool memPool, aclrtMemPoolAttr attr, void *value)
2045 : {
2046 2 : ACL_PROFILING_REG(acl::AclProfType::AclrtMemPoolGetAttr);
2047 1 : ACL_LOG_INFO("start to execute aclrtMemPoolGetAttr.");
2048 1 : ACL_REQUIRES_NOT_NULL_WITH_INNER_REPORT(memPool);
2049 :
2050 1 : const auto rtErr = rtMemPoolGetAttr(static_cast<rtMemPool_t>(memPool), static_cast<rtMemPoolAttr>(attr), value);
2051 1 : if (rtErr != RT_ERROR_NONE) {
2052 0 : ACL_LOG_CALL_ERROR("call rtMemPoolGetAttr failed, runtime result = %d.", rtErr);
2053 0 : return ACL_GET_ERRCODE_RTS(rtErr);
2054 : }
2055 1 : return ACL_SUCCESS;
2056 : }
|
