Line data Source code
1 : /**
2 : * Copyright (c) 2026 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 "ccu_primitives_impl.h"
12 :
13 : #include "ccu_log.h"
14 : #include "hcom_common.h"
15 :
16 : #include "ccu_kernel_mgr.h"
17 :
18 : namespace {
19 : // strict 校验:magic 不符 / version 越界 / size 不匹配当前版本一律拒绝。
20 40 : CcuResult ValidateCcuCfgHeader(const CcuCfgHeader* header, uint32_t expectSize, uint32_t maxVersion)
21 : {
22 40 : if (header == nullptr) {
23 0 : return CcuResult::CCU_E_PTR;
24 : }
25 40 : if (header->magic != CCU_CFG_MAGIC_WORD) {
26 2 : HCCL_ERROR("[ValidateCcuCfgHeader] bad magic 0x%x", header->magic);
27 2 : return CcuResult::CCU_E_PARA;
28 : }
29 38 : if (header->version == 0 || header->version > maxVersion) {
30 0 : HCCL_ERROR("[ValidateCcuCfgHeader] bad version %u (max %u)", header->version, maxVersion);
31 0 : return CcuResult::CCU_E_PARA;
32 : }
33 38 : if (header->size != expectSize) {
34 0 : HCCL_ERROR("[ValidateCcuCfgHeader] bad size %u (expect %u)", header->size, expectSize);
35 0 : return CcuResult::CCU_E_PARA;
36 : }
37 38 : return CcuResult::CCU_SUCCESS;
38 : }
39 : } // namespace
40 :
41 : // Alloc 相关接口
42 496 : CcuResult CcuVariableAlloc(CcuVariableHandle* varHandle)
43 : {
44 496 : const uint32_t devLogicId = HcclGetThreadDeviceId();
45 496 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
46 496 : CCU_CHK_PTR_NULL(kernel);
47 496 : CCU_CHK_RET(kernel->VariableAlloc(varHandle));
48 496 : return CcuResult::CCU_SUCCESS;
49 : }
50 :
51 10 : CcuResult CcuAddressAlloc(CcuAddressHandle* addrHandle)
52 : {
53 10 : const uint32_t devLogicId = HcclGetThreadDeviceId();
54 10 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
55 10 : CCU_CHK_PTR_NULL(kernel);
56 10 : CCU_CHK_RET(kernel->AddressAlloc(addrHandle));
57 10 : return CcuResult::CCU_SUCCESS;
58 : }
59 :
60 10 : CcuResult CcuEventAlloc(CcuEventHandle* eventHandle)
61 : {
62 10 : const uint32_t devLogicId = HcclGetThreadDeviceId();
63 10 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
64 10 : CCU_CHK_PTR_NULL(kernel);
65 10 : CCU_CHK_RET(kernel->EventAlloc(eventHandle));
66 10 : return CcuResult::CCU_SUCCESS;
67 : }
68 :
69 2 : CcuResult CcuBufferAlloc(CcuBufferHandle* bufHandle)
70 : {
71 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
72 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
73 2 : CCU_CHK_PTR_NULL(kernel);
74 2 : CCU_CHK_RET(kernel->BufferAlloc(bufHandle));
75 2 : return CcuResult::CCU_SUCCESS;
76 : }
77 :
78 : CcuResult
79 156 : CcuLocalAddrAlloc(CcuLocalAddrHandle* localAddrHandle, CcuAddressHandle* addrHandle, CcuVariableHandle* tokenHandle)
80 : {
81 156 : const uint32_t devLogicId = HcclGetThreadDeviceId();
82 156 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
83 156 : CCU_CHK_PTR_NULL(kernel);
84 156 : CCU_CHK_RET(kernel->LocalAddrAlloc(localAddrHandle, addrHandle, tokenHandle));
85 156 : return CcuResult::CCU_SUCCESS;
86 : }
87 :
88 : CcuResult
89 37 : CcuRemoteAddrAlloc(CcuRemoteAddrHandle* remoteAddrHandle, CcuAddressHandle* addrHandle, CcuVariableHandle* tokenHandle)
90 : {
91 37 : const uint32_t devLogicId = HcclGetThreadDeviceId();
92 37 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
93 37 : CCU_CHK_PTR_NULL(kernel);
94 37 : CCU_CHK_RET(kernel->RemoteAddrAlloc(remoteAddrHandle, addrHandle, tokenHandle));
95 37 : return CcuResult::CCU_SUCCESS;
96 : }
97 :
98 6 : CcuResult CcuBlockVariableAlloc(CcuVariableHandle* varHandles, uint32_t count)
99 : {
100 6 : const uint32_t devLogicId = HcclGetThreadDeviceId();
101 6 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
102 6 : CCU_CHK_PTR_NULL(kernel);
103 6 : CCU_CHK_RET(kernel->BlockVariableAlloc(varHandles, count));
104 6 : return CcuResult::CCU_SUCCESS;
105 : }
106 :
107 6 : CcuResult CcuBlockEventAlloc(CcuEventHandle* eventHandles, uint32_t count)
108 : {
109 6 : const uint32_t devLogicId = HcclGetThreadDeviceId();
110 6 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
111 6 : CCU_CHK_PTR_NULL(kernel);
112 6 : CCU_CHK_RET(kernel->BlockEventAlloc(eventHandles, count));
113 6 : return CcuResult::CCU_SUCCESS;
114 : }
115 7 : CcuResult CcuBlockBufferAlloc(CcuBufferHandle* bufHandles, uint32_t count)
116 : {
117 7 : const uint32_t devLogicId = HcclGetThreadDeviceId();
118 7 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
119 7 : CCU_CHK_PTR_NULL(kernel);
120 7 : CCU_CHK_RET(kernel->BlockBufferAlloc(bufHandles, count));
121 7 : return CcuResult::CCU_SUCCESS;
122 : }
123 14 : CcuResult CcuVariableCreateByChannel(ChannelHandle channel, uint32_t varIndex, CcuVariableHandle* varHandle)
124 : {
125 14 : const uint32_t devLogicId = HcclGetThreadDeviceId();
126 14 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
127 14 : CCU_CHK_PTR_NULL(kernel);
128 14 : CCU_CHK_RET(kernel->VariableCreateByChannel(channel, varIndex, varHandle));
129 14 : return CcuResult::CCU_SUCCESS;
130 : }
131 :
132 10 : CcuResult CcuVariableGetByIndex(CcuVariableHandle acqHandle, uint32_t index, CcuVariableHandle* varHandle)
133 : {
134 10 : CCU_CHK_PTR_NULL(varHandle);
135 10 : const uint32_t devLogicId = HcclGetThreadDeviceId();
136 10 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
137 10 : CCU_CHK_PTR_NULL(kernel);
138 10 : CCU_CHK_RET(kernel->VariableCreateByAcquire(acqHandle, index, varHandle));
139 10 : return CcuResult::CCU_SUCCESS;
140 : }
141 :
142 4 : CcuResult CcuEventGetByIndex(CcuEventHandle acqHandle, uint32_t index, CcuEventHandle* eventHandle)
143 : {
144 4 : CCU_CHK_PTR_NULL(eventHandle);
145 4 : const uint32_t devLogicId = HcclGetThreadDeviceId();
146 4 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
147 4 : CCU_CHK_PTR_NULL(kernel);
148 4 : CCU_CHK_RET(kernel->EventCreateByAcquire(acqHandle, index, eventHandle));
149 4 : return CcuResult::CCU_SUCCESS;
150 : }
151 :
152 : // Variable操作类 相关接口
153 283 : CcuResult CcuVariableAssignImm(CcuVariableHandle resVar, uint64_t immediate)
154 : {
155 283 : const uint32_t devLogicId = HcclGetThreadDeviceId();
156 283 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
157 283 : CCU_CHK_PTR_NULL(kernel);
158 283 : CCU_CHK_RET(kernel->VariableAssignImm(resVar, immediate));
159 :
160 283 : return CcuResult::CCU_SUCCESS;
161 : }
162 158 : CcuResult CcuVariableAssignVar(CcuVariableHandle dstVarHandle, CcuVariableHandle srcVarHandle)
163 : {
164 158 : const uint32_t devLogicId = HcclGetThreadDeviceId();
165 158 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
166 158 : CCU_CHK_PTR_NULL(kernel);
167 158 : CCU_CHK_RET(kernel->VariableAssignVar(dstVarHandle, srcVarHandle));
168 :
169 158 : return CcuResult::CCU_SUCCESS;
170 : }
171 :
172 109 : CcuResult CcuVariableAddVarToVar(CcuVariableHandle resVar, CcuVariableHandle varA, CcuVariableHandle varB)
173 : {
174 109 : const uint32_t devLogicId = HcclGetThreadDeviceId();
175 109 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
176 109 : CCU_CHK_PTR_NULL(kernel);
177 109 : CCU_CHK_RET(kernel->VariableAddVarToVar(resVar, varA, varB));
178 :
179 109 : return CcuResult::CCU_SUCCESS;
180 : }
181 :
182 2 : CcuResult CcuVariableSubVarToVar(CcuVariableHandle resVar, CcuVariableHandle varA, CcuVariableHandle varB)
183 : {
184 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
185 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
186 2 : CCU_CHK_PTR_NULL(kernel);
187 2 : CCU_CHK_RET(kernel->VariableSubVarToVar(resVar, varA, varB));
188 :
189 2 : return CcuResult::CCU_SUCCESS;
190 : }
191 :
192 2 : CcuResult CcuVariableMulVarToVar(CcuVariableHandle resVar, CcuVariableHandle varA, CcuVariableHandle varB)
193 : {
194 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
195 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
196 2 : CCU_CHK_PTR_NULL(kernel);
197 2 : CCU_CHK_RET(kernel->VariableMulVarToVar(resVar, varA, varB));
198 :
199 2 : return CcuResult::CCU_SUCCESS;
200 : }
201 :
202 1 : CcuResult CcuVariableAddImmToVar(CcuVariableHandle resVar, CcuVariableHandle varA, uint16_t immediate)
203 : {
204 1 : const uint32_t devLogicId = HcclGetThreadDeviceId();
205 1 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
206 1 : CCU_CHK_PTR_NULL(kernel);
207 1 : CCU_CHK_RET(kernel->VariableAddImmToVar(resVar, varA, immediate));
208 :
209 1 : return CcuResult::CCU_SUCCESS;
210 : }
211 :
212 2 : CcuResult CcuVariableSubImmToVar(CcuVariableHandle resVar, CcuVariableHandle varA, uint16_t immediate)
213 : {
214 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
215 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
216 2 : CCU_CHK_PTR_NULL(kernel);
217 2 : CCU_CHK_RET(kernel->VariableSubImmToVar(resVar, varA, immediate));
218 :
219 2 : return CcuResult::CCU_SUCCESS;
220 : }
221 :
222 2 : CcuResult CcuVariableMulImmToVar(CcuVariableHandle resVar, CcuVariableHandle varA, uint16_t immediate)
223 : {
224 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
225 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
226 2 : CCU_CHK_PTR_NULL(kernel);
227 2 : CCU_CHK_RET(kernel->VariableMulImmToVar(resVar, varA, immediate));
228 :
229 2 : return CcuResult::CCU_SUCCESS;
230 : }
231 :
232 2 : CcuResult CcuVariableAndVarToVar(CcuVariableHandle resVar, CcuVariableHandle varA, CcuVariableHandle varB)
233 : {
234 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
235 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
236 2 : CCU_CHK_PTR_NULL(kernel);
237 2 : CCU_CHK_RET(kernel->VariableAndVarToVar(resVar, varA, varB));
238 :
239 2 : return CcuResult::CCU_SUCCESS;
240 : }
241 :
242 2 : CcuResult CcuVariableOrVarToVar(CcuVariableHandle resVar, CcuVariableHandle varA, CcuVariableHandle varB)
243 : {
244 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
245 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
246 2 : CCU_CHK_PTR_NULL(kernel);
247 2 : CCU_CHK_RET(kernel->VariableOrVarToVar(resVar, varA, varB));
248 :
249 2 : return CcuResult::CCU_SUCCESS;
250 : }
251 :
252 2 : CcuResult CcuVariableXorVarToVar(CcuVariableHandle resVar, CcuVariableHandle varA, CcuVariableHandle varB)
253 : {
254 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
255 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
256 2 : CCU_CHK_PTR_NULL(kernel);
257 2 : CCU_CHK_RET(kernel->VariableXorVarToVar(resVar, varA, varB));
258 :
259 2 : return CcuResult::CCU_SUCCESS;
260 : }
261 :
262 1 : CcuResult CcuVariableNotVar(CcuVariableHandle resVar, CcuVariableHandle varA)
263 : {
264 1 : const uint32_t devLogicId = HcclGetThreadDeviceId();
265 1 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
266 1 : CCU_CHK_PTR_NULL(kernel);
267 1 : CCU_CHK_RET(kernel->VariableNotVar(resVar, varA));
268 :
269 1 : return CcuResult::CCU_SUCCESS;
270 : }
271 :
272 2 : CcuResult CcuVariableShlVarToVar(CcuVariableHandle resVar, CcuVariableHandle varA, CcuVariableHandle varB)
273 : {
274 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
275 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
276 2 : CCU_CHK_PTR_NULL(kernel);
277 2 : CCU_CHK_RET(kernel->VariableShlVarToVar(resVar, varA, varB));
278 :
279 2 : return CcuResult::CCU_SUCCESS;
280 : }
281 :
282 2 : CcuResult CcuVariableShrVarToVar(CcuVariableHandle resVar, CcuVariableHandle varA, CcuVariableHandle varB)
283 : {
284 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
285 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
286 2 : CCU_CHK_PTR_NULL(kernel);
287 2 : CCU_CHK_RET(kernel->VariableShrVarToVar(resVar, varA, varB));
288 :
289 2 : return CcuResult::CCU_SUCCESS;
290 : }
291 :
292 : /*
293 : Address 相关接口
294 : */
295 13 : CcuResult CcuAddressAssignImm(CcuAddressHandle addr, uint64_t immediate)
296 : {
297 13 : const uint32_t devLogicId = HcclGetThreadDeviceId();
298 13 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
299 13 : CCU_CHK_PTR_NULL(kernel);
300 13 : CCU_CHK_RET(kernel->AddressAssignImm(addr, immediate));
301 13 : return CcuResult::CCU_SUCCESS;
302 : }
303 :
304 38 : CcuResult CcuAddressAssignAddr(CcuAddressHandle dstAddrHandle, CcuAddressHandle srcAddrHandle)
305 : {
306 38 : const uint32_t devLogicId = HcclGetThreadDeviceId();
307 38 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
308 38 : CCU_CHK_PTR_NULL(kernel);
309 38 : CCU_CHK_RET(kernel->AddressAssignAddr(dstAddrHandle, srcAddrHandle));
310 38 : return CcuResult::CCU_SUCCESS;
311 : }
312 :
313 14 : CcuResult CcuAddressAssignVar(CcuAddressHandle addr, CcuVariableHandle var)
314 : {
315 14 : const uint32_t devLogicId = HcclGetThreadDeviceId();
316 14 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
317 14 : CCU_CHK_PTR_NULL(kernel);
318 14 : CCU_CHK_RET(kernel->AddressAssignVar(addr, var));
319 14 : return CcuResult::CCU_SUCCESS;
320 : }
321 :
322 0 : CcuResult CcuAddressAddVarToAddr(CcuAddressHandle resAddr, CcuAddressHandle lhsAddr, CcuVariableHandle rhsVar)
323 : {
324 0 : const uint32_t devLogicId = HcclGetThreadDeviceId();
325 0 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
326 0 : CCU_CHK_PTR_NULL(kernel);
327 0 : CCU_CHK_RET(kernel->AddressAddVarToAddr(resAddr, lhsAddr, rhsVar));
328 0 : return CcuResult::CCU_SUCCESS;
329 : }
330 :
331 2 : CcuResult CcuAddressAddAddrToAddr(CcuAddressHandle resAddr, CcuAddressHandle addrA, CcuAddressHandle addrB)
332 : {
333 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
334 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
335 2 : CCU_CHK_PTR_NULL(kernel);
336 2 : CCU_CHK_RET(kernel->AddressAddAddrToAddr(resAddr, addrA, addrB));
337 2 : return CcuResult::CCU_SUCCESS;
338 : }
339 :
340 41 : CcuResult CcuAddressAddAssignVar(CcuAddressHandle addr, CcuVariableHandle var)
341 : {
342 41 : const uint32_t devLogicId = HcclGetThreadDeviceId();
343 41 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
344 41 : CCU_CHK_PTR_NULL(kernel);
345 41 : CCU_CHK_RET(kernel->AddressAddAssignVar(addr, var));
346 41 : return CcuResult::CCU_SUCCESS;
347 : }
348 :
349 1 : CcuResult CcuAddressAddImmToAddr(CcuAddressHandle resAddr, CcuAddressHandle addrA, uint16_t imm)
350 : {
351 1 : const uint32_t devLogicId = HcclGetThreadDeviceId();
352 1 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
353 1 : CCU_CHK_PTR_NULL(kernel);
354 1 : CCU_CHK_RET(kernel->AddressAddImmToAddr(resAddr, addrA, imm));
355 1 : return CcuResult::CCU_SUCCESS;
356 : }
357 :
358 : // 参数加载类 相关接口
359 49 : CcuResult CcuLoadArg(CcuVariableHandle varHandle, uint32_t argId)
360 : {
361 49 : const uint32_t devLogicId = HcclGetThreadDeviceId();
362 49 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
363 49 : CCU_CHK_PTR_NULL(kernel);
364 49 : CCU_CHK_RET(kernel->LoadArg(varHandle, argId));
365 49 : return CcuResult::CCU_SUCCESS;
366 : }
367 :
368 6 : CcuResult CcuLoadVar(uint64_t addr, CcuVariableHandle varHandle, uint32_t num)
369 : {
370 6 : if (num == 0) {
371 0 : HCCL_ERROR("[CcuLoadVar] invalid args, num[%u]", num);
372 0 : return CcuResult::CCU_E_PARA;
373 : }
374 6 : const uint32_t devLogicId = HcclGetThreadDeviceId();
375 6 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
376 6 : CCU_CHK_PTR_NULL(kernel);
377 6 : CCU_CHK_RET(kernel->LoadVar(addr, varHandle, num));
378 6 : return CcuResult::CCU_SUCCESS;
379 : }
380 :
381 2 : CcuResult CcuLoadVarFromVarAddr(CcuVariableHandle addrHandle, CcuVariableHandle varHandle, uint32_t num)
382 : {
383 2 : if (num == 0) {
384 0 : HCCL_ERROR("[CcuLoadVarFromVarAddr] invalid args, num[%u]", num);
385 0 : return CcuResult::CCU_E_PARA;
386 : }
387 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
388 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
389 2 : CCU_CHK_PTR_NULL(kernel);
390 2 : CCU_CHK_RET(kernel->CcuLoadVarFromVarAddr(addrHandle, varHandle, num));
391 2 : return CcuResult::CCU_SUCCESS;
392 : }
393 :
394 3 : CcuResult CcuStoreVar(uint64_t addr, CcuVariableHandle varHandle, uint32_t num)
395 : {
396 3 : if (num == 0) {
397 0 : HCCL_ERROR("[CcuStoreVar] invalid args, num[%u]", num);
398 0 : return CcuResult::CCU_E_PARA;
399 : }
400 3 : const uint32_t devLogicId = HcclGetThreadDeviceId();
401 3 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
402 3 : CCU_CHK_PTR_NULL(kernel);
403 3 : CCU_CHK_RET(kernel->StoreVar(addr, varHandle, num));
404 3 : return CcuResult::CCU_SUCCESS;
405 : }
406 :
407 2 : CcuResult CcuStoreVarToVarAddr(CcuVariableHandle addrHandle, CcuVariableHandle varHandle, uint32_t num)
408 : {
409 2 : if (num == 0) {
410 0 : HCCL_ERROR("[CcuStoreVarToVarAddr] invalid args, num[%u]", num);
411 0 : return CcuResult::CCU_E_PARA;
412 : }
413 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
414 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
415 2 : CCU_CHK_PTR_NULL(kernel);
416 2 : CCU_CHK_RET(kernel->CcuStoreVarToVarAddr(addrHandle, varHandle, num));
417 2 : return CcuResult::CCU_SUCCESS;
418 : }
419 :
420 : // Event信号同步类 相关接口
421 15 : CcuResult CcuEventRecord(CcuEventHandle eventHandle, uint16_t mask)
422 : {
423 15 : const uint32_t devLogicId = HcclGetThreadDeviceId();
424 15 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
425 15 : CCU_CHK_PTR_NULL(kernel);
426 15 : CCU_CHK_RET(kernel->EventRecord(eventHandle, mask));
427 14 : return CcuResult::CCU_SUCCESS;
428 : }
429 41 : CcuResult CcuEventWait(CcuEventHandle eventHandle, uint16_t mask)
430 : {
431 41 : const uint32_t devLogicId = HcclGetThreadDeviceId();
432 41 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
433 41 : CCU_CHK_PTR_NULL(kernel);
434 41 : CCU_CHK_RET(kernel->EventWait(eventHandle, mask));
435 41 : return CcuResult::CCU_SUCCESS;
436 : }
437 6 : CcuResult CcuNotifyRecord(ChannelHandle channel, uint32_t remoteNotifyIdx, uint16_t mask)
438 : {
439 6 : const uint32_t devLogicId = HcclGetThreadDeviceId();
440 6 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
441 6 : CCU_CHK_PTR_NULL(kernel);
442 6 : CCU_CHK_RET(kernel->NotifyRecord(channel, remoteNotifyIdx, mask));
443 5 : return CcuResult::CCU_SUCCESS;
444 : }
445 11 : CcuResult CcuNotifyWait(ChannelHandle channel, uint32_t localNotifyIdx, uint16_t mask)
446 : {
447 11 : const uint32_t devLogicId = HcclGetThreadDeviceId();
448 11 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
449 11 : CCU_CHK_PTR_NULL(kernel);
450 11 : CCU_CHK_RET(kernel->NotifyWait(channel, localNotifyIdx, mask));
451 10 : return CcuResult::CCU_SUCCESS;
452 : }
453 10 : CcuResult CcuWriteVariableWithNotify(
454 : ChannelHandle channel, CcuVariableHandle varHandle, uint32_t remoteVarIdx, uint32_t remoteNotifyIdx, uint16_t mask)
455 : {
456 10 : const uint32_t devLogicId = HcclGetThreadDeviceId();
457 10 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
458 10 : CCU_CHK_PTR_NULL(kernel);
459 10 : CCU_CHK_RET(kernel->WriteVariableWithNotify(channel, varHandle, remoteVarIdx, remoteNotifyIdx, mask));
460 9 : return CcuResult::CCU_SUCCESS;
461 : }
462 1 : CcuResult CcuLocalNotifyRecord(const char* notifyTag, uint16_t mask)
463 : {
464 1 : CCU_CHK_PTR_NULL(notifyTag);
465 1 : const uint32_t devLogicId = HcclGetThreadDeviceId();
466 1 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
467 1 : CCU_CHK_PTR_NULL(kernel);
468 1 : CCU_CHK_RET(kernel->LocalNotifyRecord(notifyTag, mask));
469 0 : return CcuResult::CCU_SUCCESS;
470 : }
471 0 : CcuResult CcuLocalNotifyWait(const char* notifyTag, uint16_t mask)
472 : {
473 0 : CCU_CHK_PTR_NULL(notifyTag);
474 0 : const uint32_t devLogicId = HcclGetThreadDeviceId();
475 0 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
476 0 : CCU_CHK_PTR_NULL(kernel);
477 0 : CCU_CHK_RET(kernel->LocalNotifyWait(notifyTag, mask));
478 0 : return CcuResult::CCU_SUCCESS;
479 : }
480 :
481 : // 本地数据拷贝 相关接口
482 1 : CcuResult CcuLocalCopyMemToMem(
483 : CcuLocalAddrHandle dst, CcuLocalAddrHandle src, CcuVariableHandle len, CcuEventHandle event, uint16_t mask)
484 : {
485 1 : const uint32_t devLogicId = HcclGetThreadDeviceId();
486 1 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
487 1 : CCU_CHK_PTR_NULL(kernel);
488 1 : CCU_CHK_RET(kernel->LocalCopyMemToMem(dst, src, len, event, mask));
489 1 : return CcuResult::CCU_SUCCESS;
490 : }
491 :
492 12 : CcuResult CcuLocalCopyMemToBuffer(
493 : CcuBufferHandle dst, CcuLocalAddrHandle src, CcuVariableHandle len, CcuEventHandle event, uint16_t mask)
494 : {
495 12 : const uint32_t devLogicId = HcclGetThreadDeviceId();
496 12 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
497 12 : CCU_CHK_PTR_NULL(kernel);
498 12 : CCU_CHK_RET(kernel->LocalCopyMemToBuffer(dst, src, len, event, mask));
499 12 : return CcuResult::CCU_SUCCESS;
500 : }
501 :
502 8 : CcuResult CcuLocalCopyBufferToMem(
503 : CcuLocalAddrHandle dst, CcuBufferHandle src, CcuVariableHandle len, CcuEventHandle event, uint16_t mask)
504 : {
505 8 : const uint32_t devLogicId = HcclGetThreadDeviceId();
506 8 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
507 8 : CCU_CHK_PTR_NULL(kernel);
508 8 : CCU_CHK_RET(kernel->LocalCopyBufferToMem(dst, src, len, event, mask));
509 8 : return CcuResult::CCU_SUCCESS;
510 : }
511 : // 本地reduce 相关接口
512 0 : CcuResult CcuLocalMemReduce(
513 : CcuLocalAddrHandle dst, CcuLocalAddrHandle src, CcuVariableHandle len, HcclDataType dataType, HcclReduceOp opType,
514 : CcuEventHandle event, uint16_t mask)
515 : {
516 0 : const uint32_t devLogicId = HcclGetThreadDeviceId();
517 0 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
518 0 : CCU_CHK_PTR_NULL(kernel);
519 0 : CCU_CHK_RET(kernel->LocalMemReduce(dst, src, len, dataType, opType, event, mask));
520 0 : return CcuResult::CCU_SUCCESS;
521 : }
522 :
523 4 : CcuResult CcuLocalBufferReduce(
524 : CcuBufferHandle* buffers, uint32_t count, HcclDataType dataType, HcclDataType outputDataType, HcclReduceOp opType,
525 : CcuVariableHandle len, CcuEventHandle event, uint16_t mask)
526 : {
527 4 : if (buffers == nullptr || count == 0) {
528 0 : HCCL_ERROR("[CcuLocalBufferReduce] invalid args, buffers[%p] count[%u]", buffers, count);
529 0 : return CcuResult::CCU_E_PARA;
530 : }
531 4 : const uint32_t devLogicId = HcclGetThreadDeviceId();
532 4 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
533 4 : CCU_CHK_PTR_NULL(kernel);
534 4 : CCU_CHK_RET(kernel->LocalBufferReduce(buffers, count, dataType, outputDataType, opType, len, event, mask));
535 4 : return CcuResult::CCU_SUCCESS;
536 : }
537 :
538 : /*========== 远端数据传输操作 ==========*/
539 4 : CcuResult CcuReadMemToMem(
540 : ChannelHandle channel, CcuLocalAddrHandle localHandle, CcuRemoteAddrHandle remoteHandle, CcuVariableHandle len,
541 : CcuEventHandle event, uint16_t mask)
542 : {
543 4 : const uint32_t devLogicId = HcclGetThreadDeviceId();
544 4 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
545 4 : CCU_CHK_PTR_NULL(kernel);
546 4 : CCU_CHK_RET(kernel->ReadMemToMem(channel, localHandle, remoteHandle, len, event, mask));
547 4 : return CcuResult::CCU_SUCCESS;
548 : }
549 :
550 2 : CcuResult CcuReadMemToBuffer(
551 : ChannelHandle channel, CcuBufferHandle localHandle, CcuRemoteAddrHandle remoteHandle, CcuVariableHandle len,
552 : CcuEventHandle event, uint16_t mask)
553 : {
554 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
555 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
556 2 : CCU_CHK_PTR_NULL(kernel);
557 2 : CCU_CHK_RET(kernel->ReadMemToBuffer(channel, localHandle, remoteHandle, len, event, mask));
558 2 : return CcuResult::CCU_SUCCESS;
559 : }
560 :
561 2 : CcuResult CcuReadMemToMemReduce(
562 : ChannelHandle channel, CcuLocalAddrHandle localHandle, CcuRemoteAddrHandle remoteHandle, CcuVariableHandle len,
563 : HcclDataType dataType, HcclReduceOp opType, CcuEventHandle event, uint16_t mask)
564 : {
565 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
566 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
567 2 : CCU_CHK_PTR_NULL(kernel);
568 2 : CCU_CHK_RET(kernel->ReadMemToMemReduce(channel, localHandle, remoteHandle, len, dataType, opType, event, mask));
569 2 : return CcuResult::CCU_SUCCESS;
570 : }
571 :
572 3 : CcuResult CcuWriteMemToMem(
573 : ChannelHandle channel, CcuRemoteAddrHandle remoteHandle, CcuLocalAddrHandle localHandle, CcuVariableHandle len,
574 : CcuEventHandle event, uint16_t mask)
575 : {
576 3 : const uint32_t devLogicId = HcclGetThreadDeviceId();
577 3 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
578 3 : CCU_CHK_PTR_NULL(kernel);
579 3 : CCU_CHK_RET(kernel->WriteMemToMem(channel, remoteHandle, localHandle, len, event, mask));
580 3 : return CcuResult::CCU_SUCCESS;
581 : }
582 :
583 2 : CcuResult CcuWriteBufferToMem(
584 : ChannelHandle channel, CcuRemoteAddrHandle remote, CcuBufferHandle local, CcuVariableHandle len,
585 : CcuEventHandle event, uint16_t mask)
586 : {
587 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
588 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
589 2 : CCU_CHK_PTR_NULL(kernel);
590 2 : CCU_CHK_RET(kernel->WriteBufferToMem(channel, remote, local, len, event, mask));
591 2 : return CcuResult::CCU_SUCCESS;
592 : }
593 :
594 2 : CcuResult CcuWriteMemToMemReduce(
595 : ChannelHandle channel, CcuRemoteAddrHandle remote, CcuLocalAddrHandle local, CcuVariableHandle len,
596 : HcclDataType dataType, HcclReduceOp opType, CcuEventHandle event, uint16_t mask)
597 : {
598 2 : const uint32_t devLogicId = HcclGetThreadDeviceId();
599 2 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
600 2 : CCU_CHK_PTR_NULL(kernel);
601 2 : CCU_CHK_RET(kernel->WriteMemToMemReduce(channel, remote, local, len, dataType, opType, event, mask));
602 2 : return CcuResult::CCU_SUCCESS;
603 : }
604 :
605 : /*========== 控制流操作 ==========*/
606 102 : CcuResult CcuIfBegin(CcuVariableHandle var, uint64_t immediate, CcuConditionType condType, const char* label)
607 : {
608 102 : const uint32_t devLogicId = HcclGetThreadDeviceId();
609 102 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
610 102 : CCU_CHK_PTR_NULL(kernel);
611 102 : CCU_CHK_RET(kernel->IfBegin(var, immediate, condType, label));
612 :
613 101 : return CcuResult::CCU_SUCCESS;
614 : }
615 :
616 22 : CcuResult CcuIfElse(const char* label)
617 : {
618 22 : const uint32_t devLogicId = HcclGetThreadDeviceId();
619 22 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
620 22 : CCU_CHK_PTR_NULL(kernel);
621 22 : CCU_CHK_RET(kernel->IfElse(label));
622 :
623 22 : return CcuResult::CCU_SUCCESS;
624 : }
625 :
626 22 : CcuResult CcuIfEnd(const char* label)
627 : {
628 22 : const uint32_t devLogicId = HcclGetThreadDeviceId();
629 22 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
630 22 : CCU_CHK_PTR_NULL(kernel);
631 22 : CCU_CHK_RET(kernel->IfEnd(label));
632 :
633 22 : return CcuResult::CCU_SUCCESS;
634 : }
635 :
636 104 : CcuResult CcuFlushPendingIfs()
637 : {
638 104 : const uint32_t devLogicId = HcclGetThreadDeviceId();
639 104 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
640 104 : CCU_CHK_PTR_NULL(kernel);
641 104 : kernel->FlushClosablePendingIfs();
642 104 : return CcuResult::CCU_SUCCESS;
643 : }
644 :
645 3 : CcuResult CcuWhileBegin(CcuVariableHandle var, uint64_t immediate, CcuConditionType condType, const char* label)
646 : {
647 3 : const uint32_t devLogicId = HcclGetThreadDeviceId();
648 3 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
649 3 : CCU_CHK_PTR_NULL(kernel);
650 3 : CCU_CHK_RET(kernel->WhileBegin(var, immediate, condType, label));
651 :
652 3 : return CcuResult::CCU_SUCCESS;
653 : }
654 :
655 4 : CcuResult CcuWhileEnd(const char* label)
656 : {
657 4 : const uint32_t devLogicId = HcclGetThreadDeviceId();
658 4 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
659 4 : CCU_CHK_PTR_NULL(kernel);
660 4 : CCU_CHK_RET(kernel->WhileEnd(label));
661 :
662 4 : return CcuResult::CCU_SUCCESS;
663 : }
664 :
665 6 : CcuResult CcuDoWhileBegin(const char* label)
666 : {
667 6 : const uint32_t devLogicId = HcclGetThreadDeviceId();
668 6 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
669 6 : CCU_CHK_PTR_NULL(kernel);
670 6 : CCU_CHK_RET(kernel->DoWhileBegin(label));
671 :
672 6 : return CcuResult::CCU_SUCCESS;
673 : }
674 :
675 5 : CcuResult CcuDoWhileEnd(CcuVariableHandle var, uint64_t immediate, CcuConditionType condType, const char* label)
676 : {
677 5 : const uint32_t devLogicId = HcclGetThreadDeviceId();
678 5 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
679 5 : CCU_CHK_PTR_NULL(kernel);
680 5 : CCU_CHK_RET(kernel->DoWhileEnd(var, immediate, condType, label));
681 :
682 5 : return CcuResult::CCU_SUCCESS;
683 : }
684 :
685 3 : CcuResult CcuIfBeginVar(CcuVariableHandle lhs, CcuVariableHandle rhs, CcuConditionType condType, const char* label)
686 : {
687 3 : const uint32_t devLogicId = HcclGetThreadDeviceId();
688 3 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
689 3 : CCU_CHK_PTR_NULL(kernel);
690 3 : CCU_CHK_RET(kernel->IfBeginVar(lhs, rhs, condType, label));
691 :
692 3 : return CcuResult::CCU_SUCCESS;
693 : }
694 :
695 1 : CcuResult CcuWhileBeginVar(CcuVariableHandle lhs, CcuVariableHandle rhs, CcuConditionType condType, const char* label)
696 : {
697 1 : const uint32_t devLogicId = HcclGetThreadDeviceId();
698 1 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
699 1 : CCU_CHK_PTR_NULL(kernel);
700 1 : CCU_CHK_RET(kernel->WhileBeginVar(lhs, rhs, condType, label));
701 :
702 1 : return CcuResult::CCU_SUCCESS;
703 : }
704 :
705 1 : CcuResult CcuDoWhileEndVar(CcuVariableHandle lhs, CcuVariableHandle rhs, CcuConditionType condType, const char* label)
706 : {
707 1 : const uint32_t devLogicId = HcclGetThreadDeviceId();
708 1 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
709 1 : CCU_CHK_PTR_NULL(kernel);
710 1 : CCU_CHK_RET(kernel->DoWhileEndVar(lhs, rhs, condType, label));
711 :
712 1 : return CcuResult::CCU_SUCCESS;
713 : }
714 :
715 : /*========== 函数调用操作 ==========*/
716 8 : CcuResult CcuFuncBlockLookup(const void* funcPtr, uint64_t* outHandle)
717 : {
718 8 : const uint32_t devLogicId = HcclGetThreadDeviceId();
719 8 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
720 8 : CCU_CHK_PTR_NULL(kernel);
721 8 : CCU_CHK_RET(kernel->FuncBlockLookup(funcPtr, outHandle));
722 6 : return CcuResult::CCU_SUCCESS;
723 : }
724 :
725 5 : CcuResult CcuFuncBlockBegin(const void* funcPtr, uint64_t* outHandle)
726 : {
727 5 : const uint32_t devLogicId = HcclGetThreadDeviceId();
728 5 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
729 5 : CCU_CHK_PTR_NULL(kernel);
730 5 : CCU_CHK_RET(kernel->FuncBlockBegin(funcPtr, outHandle));
731 5 : return CcuResult::CCU_SUCCESS;
732 : }
733 :
734 4 : CcuResult CcuFuncBlockEnd(uint64_t handle)
735 : {
736 4 : const uint32_t devLogicId = HcclGetThreadDeviceId();
737 4 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
738 4 : CCU_CHK_PTR_NULL(kernel);
739 4 : CCU_CHK_RET(kernel->FuncBlockEnd(handle));
740 4 : return CcuResult::CCU_SUCCESS;
741 : }
742 :
743 7 : CcuResult CcuFuncDefineInArg(uint64_t handle, CcuVariableHandle formal)
744 : {
745 7 : const uint32_t devLogicId = HcclGetThreadDeviceId();
746 7 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
747 7 : CCU_CHK_PTR_NULL(kernel);
748 7 : CCU_CHK_RET(kernel->FuncDefineInArg(handle, formal));
749 7 : return CcuResult::CCU_SUCCESS;
750 : }
751 :
752 5 : CcuResult CcuFuncCall(uint64_t handle, const CcuVariableHandle* inArgs, uint32_t numIn)
753 : {
754 5 : const uint32_t devLogicId = HcclGetThreadDeviceId();
755 5 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
756 5 : CCU_CHK_PTR_NULL(kernel);
757 5 : CCU_CHK_RET(kernel->FuncCall(handle, inArgs, numIn));
758 5 : return CcuResult::CCU_SUCCESS;
759 : }
760 :
761 : /*========== 循环操作 ==========*/
762 51 : CcuResult CcuLoopCreate(CcuLoop* loop)
763 : {
764 51 : const uint32_t devLogicId = HcclGetThreadDeviceId();
765 51 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
766 51 : CCU_CHK_PTR_NULL(kernel);
767 51 : CCU_CHK_RET(kernel->LoopCreate(loop));
768 51 : return CcuResult::CCU_SUCCESS;
769 : }
770 :
771 51 : CcuResult _CcuLoopBodyEnter(CcuLoop loop)
772 : {
773 51 : const uint32_t devLogicId = HcclGetThreadDeviceId();
774 51 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
775 51 : CCU_CHK_PTR_NULL(kernel);
776 51 : CCU_CHK_RET(kernel->LoopBodyEnter(loop));
777 51 : return CcuResult::CCU_SUCCESS;
778 : }
779 :
780 51 : CcuResult _CcuLoopBodyExit(CcuLoop loop)
781 : {
782 51 : const uint32_t devLogicId = HcclGetThreadDeviceId();
783 51 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
784 51 : CCU_CHK_PTR_NULL(kernel);
785 51 : CCU_CHK_RET(kernel->LoopBodyExit(loop));
786 45 : return CcuResult::CCU_SUCCESS;
787 : }
788 :
789 0 : CcuResult CcuLoopGroupCreate(CcuLoopGroup* group, uint32_t maxLoopNum, const CcuLoopGroupConfig* config)
790 : {
791 0 : if (config == nullptr) {
792 0 : return CcuResult::CCU_E_PTR;
793 : }
794 : // 旧 config 无 varOffset,在边界归一化为 cfg(varOffset=0),kernel 只认 cfg。
795 0 : CcuLoopGroupCfg cfg{};
796 0 : CcuLoopGroupCfgInit(&cfg);
797 0 : cfg.cloneNum = config->cloneNum;
798 0 : cfg.cloneLoopOffset = config->cloneLoopOffset;
799 0 : cfg.addrOffset = config->addrOffset;
800 0 : cfg.ccuBufferOffset = config->ccuBufferOffset;
801 0 : cfg.eventOffset = config->eventOffset;
802 0 : cfg.varOffset = 0;
803 0 : const uint32_t devLogicId = HcclGetThreadDeviceId();
804 0 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
805 0 : CCU_CHK_PTR_NULL(kernel);
806 0 : CCU_CHK_RET(kernel->LoopGroupCreate(group, maxLoopNum, &cfg));
807 0 : return CcuResult::CCU_SUCCESS;
808 : }
809 :
810 11 : CcuResult CcuLoopGroupCreateFromVar(
811 : CcuLoopGroup* group, uint32_t maxLoopNum, CcuVariableHandle parallelVar, CcuVariableHandle offsetVar)
812 : {
813 11 : const uint32_t devLogicId = HcclGetThreadDeviceId();
814 11 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
815 11 : CCU_CHK_PTR_NULL(kernel);
816 11 : CCU_CHK_RET(kernel->LoopGroupCreateFromVar(group, maxLoopNum, parallelVar, offsetVar));
817 11 : return CcuResult::CCU_SUCCESS;
818 : }
819 :
820 5 : CcuResult CcuLoopGroupCreateFromVarV2(
821 : CcuLoopGroup* group, uint32_t maxLoopNum, CcuVariableHandle parallelVarV2, CcuVariableHandle offsetVarV2,
822 : CcuVariableHandle varOffsetVar)
823 : {
824 5 : const uint32_t devLogicId = HcclGetThreadDeviceId();
825 5 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
826 5 : CCU_CHK_PTR_NULL(kernel);
827 5 : CCU_CHK_RET(kernel->LoopGroupCreateFromVarV2(group, maxLoopNum, parallelVarV2, offsetVarV2, varOffsetVar));
828 4 : return CcuResult::CCU_SUCCESS;
829 : }
830 :
831 0 : CcuResult CcuLoopGroupAddLoop(CcuLoopGroup group, CcuLoop loop, const CcuLoopConfig* config)
832 : {
833 0 : if (config == nullptr) {
834 0 : return CcuResult::CCU_E_PTR;
835 : }
836 0 : CcuLoopCfg cfg{};
837 0 : CcuLoopCfgInit(&cfg);
838 0 : cfg.addrOffset = config->addrOffset;
839 0 : cfg.iterNum = config->iterNum;
840 0 : const uint32_t devLogicId = HcclGetThreadDeviceId();
841 0 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
842 0 : CCU_CHK_PTR_NULL(kernel);
843 0 : CCU_CHK_RET(kernel->LoopGroupAddLoop(group, loop, &cfg));
844 0 : return CcuResult::CCU_SUCCESS;
845 : }
846 :
847 14 : CcuResult CcuLoopGroupCreateCfg(CcuLoopGroup* group, uint32_t maxLoopNum, const CcuLoopGroupCfg* cfg)
848 : {
849 14 : if (cfg == nullptr) {
850 0 : return CcuResult::CCU_E_PTR;
851 : }
852 14 : CCU_CHK_RET(ValidateCcuCfgHeader(&cfg->header, sizeof(CcuLoopGroupCfg), CCU_LOOPGROUP_CFG_VERSION));
853 13 : const uint32_t devLogicId = HcclGetThreadDeviceId();
854 13 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
855 13 : CCU_CHK_PTR_NULL(kernel);
856 13 : CCU_CHK_RET(kernel->LoopGroupCreate(group, maxLoopNum, cfg));
857 13 : return CcuResult::CCU_SUCCESS;
858 : }
859 :
860 26 : CcuResult CcuLoopGroupAddLoopCfg(CcuLoopGroup group, CcuLoop loop, const CcuLoopCfg* cfg)
861 : {
862 26 : if (cfg == nullptr) {
863 0 : return CcuResult::CCU_E_PTR;
864 : }
865 26 : CCU_CHK_RET(ValidateCcuCfgHeader(&cfg->header, sizeof(CcuLoopCfg), CCU_LOOP_CFG_VERSION));
866 25 : const uint32_t devLogicId = HcclGetThreadDeviceId();
867 25 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
868 25 : CCU_CHK_PTR_NULL(kernel);
869 25 : CCU_CHK_RET(kernel->LoopGroupAddLoop(group, loop, cfg));
870 25 : return CcuResult::CCU_SUCCESS;
871 : }
872 :
873 23 : CcuResult CcuLoopGroupAddLoopFromVar(CcuLoopGroup group, CcuLoop loop, CcuVariableHandle loopParamVar)
874 : {
875 23 : const uint32_t devLogicId = HcclGetThreadDeviceId();
876 23 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
877 23 : CCU_CHK_PTR_NULL(kernel);
878 23 : CCU_CHK_RET(kernel->LoopGroupAddLoopFromVar(group, loop, loopParamVar));
879 23 : return CcuResult::CCU_SUCCESS;
880 : }
881 :
882 8 : CcuResult CcuLoopGroupAddLoopFromVarV2(
883 : CcuLoopGroup group, CcuLoop loop, CcuVariableHandle iterNumVar, CcuVariableHandle addrOffsetVar,
884 : CcuVariableHandle ctxIdVar)
885 : {
886 8 : const uint32_t devLogicId = HcclGetThreadDeviceId();
887 8 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
888 8 : CCU_CHK_PTR_NULL(kernel);
889 8 : CCU_CHK_RET(kernel->LoopGroupAddLoopFromVarV2(group, loop, iterNumVar, addrOffsetVar, ctxIdVar));
890 8 : return CcuResult::CCU_SUCCESS;
891 : }
892 :
893 : // 控制流标签栈 C 接口（_CcuIfStack* / _CcuDoWhileStack*）
894 :
895 104 : void _CcuIfStackPush(const char* label)
896 : {
897 104 : const uint32_t devLogicId = HcclGetThreadDeviceId();
898 104 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
899 104 : if (kernel == nullptr) {
900 0 : HCCL_ERROR("[_CcuIfStackPush] no current kernel, label=%s", label != nullptr ? label : "(null)");
901 0 : return;
902 : }
903 104 : kernel->IfLabelStackPush(label);
904 : }
905 :
906 104 : void _CcuIfStackMarkBodyDone()
907 : {
908 104 : const uint32_t devLogicId = HcclGetThreadDeviceId();
909 104 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
910 104 : if (kernel == nullptr) {
911 0 : HCCL_ERROR("[_CcuIfStackMarkBodyDone] no current kernel");
912 0 : return;
913 : }
914 104 : kernel->IfLabelStackMarkBodyDone();
915 : }
916 :
917 22 : const char* _CcuIfStackPopForElse()
918 : {
919 22 : const uint32_t devLogicId = HcclGetThreadDeviceId();
920 22 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
921 22 : if (kernel == nullptr) {
922 0 : HCCL_ERROR("[_CcuIfStackPopForElse] no current kernel");
923 0 : return nullptr;
924 : }
925 22 : return kernel->IfLabelStackPopForElse();
926 : }
927 :
928 6 : void _CcuDoWhileStackPush(const char* label)
929 : {
930 6 : const uint32_t devLogicId = HcclGetThreadDeviceId();
931 6 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
932 6 : if (kernel == nullptr) {
933 0 : HCCL_ERROR("[_CcuDoWhileStackPush] no current kernel, label=%s", label != nullptr ? label : "(null)");
934 0 : return;
935 : }
936 6 : kernel->DoWhileLabelStackPush(label);
937 : }
938 :
939 10 : const char* _CcuDoWhileStackPopForWhile()
940 : {
941 10 : const uint32_t devLogicId = HcclGetThreadDeviceId();
942 10 : auto kernel = hcomm::CcuKernelMgr::GetInstance(devLogicId).GetCurrentKernel();
943 10 : if (kernel == nullptr) {
944 : // 见上方注释：CCU_WHILE 每次都会调本函数做模式判别，保持沉默。
945 0 : return nullptr;
946 : }
947 10 : return kernel->DoWhileLabelStackPopForWhile();
948 : }
|
