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 "ccu_microcode_v1.h"
12 :
13 : #include <unordered_map>
14 :
15 : #include "string_util.h"
16 :
17 : namespace {
18 : constexpr uint16_t LOAD_TYPE = 0x0;
19 : constexpr uint16_t CTRL_TYPE = 0x1;
20 : constexpr uint16_t TRANS_TYPE = 0x2;
21 : constexpr uint16_t REDUCE_TYPE = 0x3;
22 :
23 : constexpr uint16_t LOADSQEARGSTOGSA_CODE = 0x0;
24 : constexpr uint16_t LOADSQEARGSTOXN_CODE = 0x1;
25 : constexpr uint16_t LOADIMDTOGSA_CODE = 0x2;
26 : constexpr uint16_t LOADIMDTOXN_CODE = 0x3;
27 : constexpr uint16_t LOADGSAXN_CODE = 0x4;
28 : constexpr uint16_t LOADGSAGSA_CODE = 0x5;
29 : constexpr uint16_t LOADXX_CODE = 0x6;
30 :
31 : constexpr uint16_t LOOP_CODE = 0x0;
32 : constexpr uint16_t LOOPGROUP_CODE = 0x1;
33 : constexpr uint16_t SETCKE_CODE = 0x2;
34 : constexpr uint16_t CLEARCKE_CODE = 0x4;
35 : constexpr uint16_t JMP_CODE = 0x5;
36 :
37 : constexpr uint16_t TRANSLOCMEMTOLOCMS_CODE = 0x0;
38 : constexpr uint16_t TRANSRMTMEMTOLOCMS_CODE = 0x1;
39 : constexpr uint16_t TRANSLOCMSTOLOCMEM_CODE = 0x2;
40 : constexpr uint16_t TRANSLOCMSTORMTMEM_CODE = 0x3;
41 : constexpr uint16_t TRANSRMTMSTOLOCMEM_CODE = 0x4;
42 : constexpr uint16_t TRANSLOCMSTOLOCMS_CODE = 0x5;
43 : constexpr uint16_t TRANSRMTMSTOLOCMS_CODE = 0x6;
44 : constexpr uint16_t TRANSLOCMSTORMTMS_CODE = 0x7;
45 : constexpr uint16_t TRANSRMTMEMTOLOCMEM_CODE = 0x8;
46 : constexpr uint16_t TRANSLOCMEMTORMTMEM_CODE = 0x9;
47 : constexpr uint16_t TRANSLOCMEMTOLOCMEM_CODE = 0xa;
48 : constexpr uint16_t SYNCCKE_CODE = 0xb;
49 : constexpr uint16_t SYNCGSA_CODE = 0xc;
50 : constexpr uint16_t SYNCXN_CODE = 0xd;
51 :
52 : constexpr uint16_t ADD_CODE = 0x0;
53 : constexpr uint16_t MAX_CODE = 0x1;
54 : constexpr uint16_t MIN_CODE = 0x2;
55 : } // namespace
56 :
57 : namespace hcomm {
58 : namespace CcuRep {
59 :
60 : // *GSAId = *sqeArgsId
61 0 : void LoadSqeArgsToGSAInstr(CcuInstr* instr, uint16_t gsaId, uint16_t sqeArgsId)
62 : {
63 0 : instr->header = InstrHeader(LOAD_TYPE, LOADSQEARGSTOGSA_CODE);
64 0 : instr->v1.loadSqeArgsToGSA.gsaId = gsaId;
65 0 : instr->v1.loadSqeArgsToGSA.sqeArgsId = sqeArgsId;
66 0 : }
67 :
68 : // *XnId = *sqeArgsId
69 33 : void LoadSqeArgsToXnInstr(CcuInstr* instr, uint16_t xnId, uint16_t sqeArgsId)
70 : {
71 33 : instr->header = InstrHeader(LOAD_TYPE, LOADSQEARGSTOXN_CODE);
72 33 : instr->v1.loadSqeArgsToXn.xnId = xnId;
73 33 : instr->v1.loadSqeArgsToXn.sqeArgsId = sqeArgsId;
74 33 : }
75 :
76 : // *GSAId = immediate
77 56 : void LoadImdToGSAInstr(CcuInstr* instr, uint16_t gsaId, uint64_t immediate)
78 : {
79 56 : instr->header = InstrHeader(LOAD_TYPE, LOADIMDTOGSA_CODE);
80 56 : instr->v1.loadImdToGSA.gsaId = gsaId;
81 56 : instr->v1.loadImdToGSA.immediate = immediate;
82 56 : }
83 :
84 : // *XnId = immediate，secFlag用于打印时判断immediate是否是敏感信息，如果是，请设置secFlag=CCU_LOAD_TO_XN_SEC_INFO
85 620 : void LoadImdToXnInstr(CcuInstr* instr, uint16_t xnId, uint64_t immediate, uint16_t secFlag)
86 : {
87 620 : instr->header = InstrHeader(LOAD_TYPE, LOADIMDTOXN_CODE);
88 620 : instr->v1.loadImdToXn.xnId = xnId;
89 620 : instr->v1.loadImdToXn.immediate = immediate;
90 620 : instr->v1.loadImdToXn.secFlag = secFlag;
91 620 : }
92 :
93 : // *GSAdId = *GSAmId + *XnId
94 44 : void LoadGSAXnInstr(CcuInstr* instr, uint16_t gsAdId, uint16_t gsAmId, uint16_t xnId)
95 : {
96 44 : instr->header = InstrHeader(LOAD_TYPE, LOADGSAXN_CODE);
97 44 : instr->v1.loadGSAXn.gsAdId = gsAdId;
98 44 : instr->v1.loadGSAXn.gsAmId = gsAmId;
99 44 : instr->v1.loadGSAXn.xnId = xnId;
100 44 : }
101 :
102 : // *GSAdId = *GSAmId + *GSAnId
103 25 : void LoadGSAGSAInstr(CcuInstr* instr, uint16_t gsAdId, uint16_t gsAmId, uint16_t gsAnId)
104 : {
105 25 : instr->header = InstrHeader(LOAD_TYPE, LOADGSAGSA_CODE);
106 25 : instr->v1.loadGSAGSA.gsAdId = gsAdId;
107 25 : instr->v1.loadGSAGSA.gsAmId = gsAmId;
108 25 : instr->v1.loadGSAGSA.gsAnId = gsAnId;
109 25 : }
110 :
111 : // *XdId = *XmId + *XnId
112 211 : void LoadXXInstr(CcuInstr* instr, uint16_t xdId, uint16_t xmId, uint16_t xnId)
113 : {
114 211 : instr->header = InstrHeader(LOAD_TYPE, LOADXX_CODE);
115 211 : instr->v1.loadXX.xdId = xdId;
116 211 : instr->v1.loadXX.xmId = xmId;
117 211 : instr->v1.loadXX.xnId = xnId;
118 211 : }
119 :
120 : // startInstrId ~ endInstrId之间的指令构成loop
121 : // Xn寄存器中的内容：LoopNum[61:55], RepeatNum[54:48], NoRepeatNum[47:41], LoopCtxId[40:33], Offset[32:13],
122 : // IterNum[12:0] loop执行IterNum次 loop每次执行, *GSA偏移为Offset loop在第LoopCtxId个LoopEngine上执行
123 39 : void LoopInstr(CcuInstr* instr, uint16_t startInstrId, uint16_t endInstrId, uint16_t xnId)
124 : {
125 39 : instr->header = InstrHeader(CTRL_TYPE, LOOP_CODE);
126 39 : instr->v1.loop.startInstrId = startInstrId;
127 39 : instr->v1.loop.endInstrId = endInstrId;
128 39 : instr->v1.loop.xnId = xnId;
129 39 : }
130 :
131 : // startLoopInstrId为LoopGroup所包含的Loop的起始地址
132 : // Xn寄存器中的内容：LoopNum[61:55], RepeatNum[54:48], NoRepeatNum[47:41], LoopCtxId[40:33], Offset[32:13],
133 : // IterNum[12:0] 不自动展开的Loop的个数：NoRepeatNum 自动展开的Loop的个数：RepeatNum 自动展开成LoopNum个Loop
134 : void
135 20 : LoopGroupInstr(CcuInstr* instr, uint16_t startLoopInstrId, uint16_t xnId, uint16_t xmId, uint16_t highPerfModeEn)
136 : {
137 20 : instr->header = InstrHeader(CTRL_TYPE, LOOPGROUP_CODE);
138 20 : instr->v1.loopGroup.startLoopInstrId = startLoopInstrId;
139 20 : instr->v1.loopGroup.xnId = xnId;
140 20 : instr->v1.loopGroup.xmId = xmId;
141 20 : instr->v1.loopGroup.highPerfModeEn = highPerfModeEn & 0x1;
142 20 : }
143 :
144 : // 后续函数中, 均需要wait到<waitCKEId, waitCKEMask>后, 再执行相关操作, 执行完之后再set<setCKEId, setCKEMask>
145 : // clearType = 1时, wait到之后需要对<waitCKEId, waitCKEMask>清零, 否则不清零
146 :
147 : // set<setCKEId, setCKEMask>
148 93 : void SetCKEInstr(
149 : CcuInstr* instr, uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask,
150 : uint16_t clearType)
151 : {
152 93 : instr->header = InstrHeader(CTRL_TYPE, SETCKE_CODE);
153 93 : instr->v1.setCKE.clearType = clearType & 0x1;
154 93 : instr->v1.setCKE.setCKEId = setCKEId;
155 93 : instr->v1.setCKE.setCKEMask = setCKEMask;
156 93 : instr->v1.setCKE.waitCKEId = waitCKEId;
157 93 : instr->v1.setCKE.waitCKEMask = waitCKEMask;
158 93 : }
159 :
160 : // clear<setCKEId, setCKEMask>
161 12 : void ClearCKEInstr(
162 : CcuInstr* instr, uint16_t clearCKEId, uint16_t clearMask, uint16_t waitCKEId, uint16_t waitCKEMask,
163 : uint16_t clearType)
164 : {
165 12 : instr->header = InstrHeader(CTRL_TYPE, CLEARCKE_CODE);
166 12 : instr->v1.clearCKE.clearType = clearType & 0x1;
167 12 : instr->v1.clearCKE.clearCKEId = clearCKEId;
168 12 : instr->v1.clearCKE.clearMask = clearMask;
169 12 : instr->v1.clearCKE.waitCKEId = waitCKEId;
170 12 : instr->v1.clearCKE.waitCKEMask = waitCKEMask;
171 12 : }
172 :
173 148 : void JumpInstr(CcuInstr* instr, uint16_t dstInstrXnId, uint16_t conditionXnId, uint64_t expectData)
174 : {
175 148 : instr->header = InstrHeader(CTRL_TYPE, JMP_CODE);
176 148 : instr->v1.jmp.dstInstrXnId = dstInstrXnId;
177 148 : instr->v1.jmp.conditionXnId = conditionXnId;
178 148 : instr->v1.jmp.expectData = expectData;
179 148 : }
180 :
181 : // 本端Memory传输到本端MS
182 : // locMSId: 本端MSId
183 : // <locGSAId, locXnId>: 本端Memory地址和Token
184 : // 数据长度: length
185 9 : void TransLocMemToLocMSInstr(
186 : CcuInstr* instr, uint16_t locMSId, uint16_t locGSAId, uint16_t locXnId, uint16_t lengthXnId, uint16_t channelId,
187 : uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType,
188 : uint16_t lengthEn)
189 : {
190 9 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMEMTOLOCMS_CODE);
191 9 : instr->v1.transLocMemToLocMS.locMSId = locMSId;
192 9 : instr->v1.transLocMemToLocMS.locGSAId = locGSAId;
193 9 : instr->v1.transLocMemToLocMS.locXnId = locXnId;
194 9 : instr->v1.transLocMemToLocMS.lengthXnId = lengthXnId;
195 9 : instr->v1.transLocMemToLocMS.channelId = channelId;
196 9 : instr->v1.transLocMemToLocMS.clearType = clearType & 0x1;
197 9 : instr->v1.transLocMemToLocMS.lengthEn = lengthEn & 0x1;
198 9 : instr->v1.transLocMemToLocMS.setCKEId = setCKEId;
199 9 : instr->v1.transLocMemToLocMS.setCKEMask = setCKEMask;
200 9 : instr->v1.transLocMemToLocMS.waitCKEId = waitCKEId;
201 9 : instr->v1.transLocMemToLocMS.waitCKEMask = waitCKEMask;
202 9 : }
203 :
204 : // 远端Memory传输到本端MS
205 : // locMSId: 本端MSId
206 : // <rmtGSAId, rmtXnId>: 远端Memory地址和Token
207 : // 数据长度: length
208 : // 路径: channelId
209 1 : void TransRmtMemToLocMSInstr(
210 : CcuInstr* instr, uint16_t locMSId, uint16_t rmtGSAId, uint16_t rmtXnId, uint16_t lengthXnId, uint16_t channelId,
211 : uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType,
212 : uint16_t lengthEn)
213 : {
214 1 : instr->header = InstrHeader(TRANS_TYPE, TRANSRMTMEMTOLOCMS_CODE);
215 1 : instr->v1.transRmtMemToLocMS.locMSId = locMSId;
216 1 : instr->v1.transRmtMemToLocMS.rmtGSAId = rmtGSAId;
217 1 : instr->v1.transRmtMemToLocMS.rmtXnId = rmtXnId;
218 1 : instr->v1.transRmtMemToLocMS.lengthXnId = lengthXnId;
219 1 : instr->v1.transRmtMemToLocMS.channelId = channelId;
220 1 : instr->v1.transRmtMemToLocMS.clearType = clearType & 0x1;
221 1 : instr->v1.transRmtMemToLocMS.lengthEn = lengthEn & 0x1;
222 1 : instr->v1.transRmtMemToLocMS.setCKEId = setCKEId;
223 1 : instr->v1.transRmtMemToLocMS.setCKEMask = setCKEMask;
224 1 : instr->v1.transRmtMemToLocMS.waitCKEId = waitCKEId;
225 1 : instr->v1.transRmtMemToLocMS.waitCKEMask = waitCKEMask;
226 1 : }
227 :
228 : // 本端MS传输到本端Memory
229 : // <locGSAId, locXnId>: 本端Memory地址和Token
230 : // locMSId: 本端MSId
231 : // 数据长度: length
232 7 : void TransLocMSToLocMemInstr(
233 : CcuInstr* instr, uint16_t locGSAId, uint16_t locXnId, uint16_t locMSId, uint16_t lengthXnId, uint16_t channelId,
234 : uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType,
235 : uint16_t lengthEn)
236 : {
237 7 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMSTOLOCMEM_CODE);
238 7 : instr->v1.transLocMSToLocMem.locGSAId = locGSAId;
239 7 : instr->v1.transLocMSToLocMem.locXnId = locXnId;
240 7 : instr->v1.transLocMSToLocMem.locMSId = locMSId;
241 7 : instr->v1.transLocMSToLocMem.lengthXnId = lengthXnId;
242 7 : instr->v1.transLocMSToLocMem.channelId = channelId;
243 7 : instr->v1.transLocMSToLocMem.clearType = clearType & 0x1;
244 7 : instr->v1.transLocMSToLocMem.lengthEn = lengthEn & 0x1;
245 7 : instr->v1.transLocMSToLocMem.setCKEId = setCKEId;
246 7 : instr->v1.transLocMSToLocMem.setCKEMask = setCKEMask;
247 7 : instr->v1.transLocMSToLocMem.waitCKEId = waitCKEId;
248 7 : instr->v1.transLocMSToLocMem.waitCKEMask = waitCKEMask;
249 7 : }
250 :
251 : // 本端MS传输到远端Memory
252 : // locMSId: 本端MSId
253 : // <rmtGSAId, rmtXnId>: 远端Memory地址和Token
254 : // 数据长度: length
255 : // 路径: channelId
256 1 : void TransLocMSToRmtMemInstr(
257 : CcuInstr* instr, uint16_t rmtGSAId, uint16_t rmtXnId, uint16_t locMSId, uint16_t lengthXnId, uint16_t channelId,
258 : uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType,
259 : uint16_t lengthEn)
260 : {
261 1 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMSTORMTMEM_CODE);
262 1 : instr->v1.transLocMSToRmtMem.rmtGSAId = rmtGSAId;
263 1 : instr->v1.transLocMSToRmtMem.rmtXnId = rmtXnId;
264 1 : instr->v1.transLocMSToRmtMem.locMSId = locMSId;
265 1 : instr->v1.transLocMSToRmtMem.lengthXnId = lengthXnId;
266 1 : instr->v1.transLocMSToRmtMem.channelId = channelId;
267 1 : instr->v1.transLocMSToRmtMem.clearType = clearType & 0x1;
268 1 : instr->v1.transLocMSToRmtMem.lengthEn = lengthEn & 0x1;
269 1 : instr->v1.transLocMSToRmtMem.setCKEId = setCKEId;
270 1 : instr->v1.transLocMSToRmtMem.setCKEMask = setCKEMask;
271 1 : instr->v1.transLocMSToRmtMem.waitCKEId = waitCKEId;
272 1 : instr->v1.transLocMSToRmtMem.waitCKEMask = waitCKEMask;
273 1 : }
274 :
275 : // 远端MS传输到本端Memory
276 : // <locGSAId, locXnId>: 本端Memory地址和Token
277 : // rmtMSId: 远端MSId
278 : // 数据长度: length
279 : // 路径: channelId
280 0 : void TransRmtMSToLocMemInstr(
281 : CcuInstr* instr, uint16_t locGSAId, uint16_t locXnId, uint16_t rmtMSId, uint16_t lengthXnId, uint16_t channelId,
282 : uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType,
283 : uint16_t lengthEn)
284 : {
285 0 : instr->header = InstrHeader(TRANS_TYPE, TRANSRMTMSTOLOCMEM_CODE);
286 0 : instr->v1.transRmtMSToLocMem.locGSAId = locGSAId;
287 0 : instr->v1.transRmtMSToLocMem.locXnId = locXnId;
288 0 : instr->v1.transRmtMSToLocMem.rmtMSId = rmtMSId;
289 0 : instr->v1.transRmtMSToLocMem.lengthXnId = lengthXnId;
290 0 : instr->v1.transRmtMSToLocMem.channelId = channelId;
291 0 : instr->v1.transRmtMSToLocMem.clearType = clearType & 0x1;
292 0 : instr->v1.transRmtMSToLocMem.lengthEn = lengthEn & 0x1;
293 0 : instr->v1.transRmtMSToLocMem.setCKEId = setCKEId;
294 0 : instr->v1.transRmtMSToLocMem.setCKEMask = setCKEMask;
295 0 : instr->v1.transRmtMSToLocMem.waitCKEId = waitCKEId;
296 0 : instr->v1.transRmtMSToLocMem.waitCKEMask = waitCKEMask;
297 0 : }
298 :
299 : // 本端MS传输到本端MS
300 : // dstMSId: 本端目的MSId
301 : // srcMSId: 本端源MSId
302 : // 数据长度: length
303 0 : void TransLocMSToLocMSInstr(
304 : CcuInstr* instr, uint16_t dstMSId, uint16_t srcMSId, uint16_t lengthXnId, uint16_t channelId, uint16_t setCKEId,
305 : uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType, uint16_t lengthEn)
306 : {
307 0 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMSTOLOCMS_CODE);
308 0 : instr->v1.transLocMSToLocMS.dstMSId = dstMSId;
309 0 : instr->v1.transLocMSToLocMS.srcMSId = srcMSId;
310 0 : instr->v1.transLocMSToLocMS.lengthXnId = lengthXnId;
311 0 : instr->v1.transLocMSToLocMS.channelId = channelId;
312 0 : instr->v1.transLocMSToLocMS.clearType = clearType & 0x1;
313 0 : instr->v1.transLocMSToLocMS.lengthEn = lengthEn & 0x1;
314 0 : instr->v1.transLocMSToLocMS.setCKEId = setCKEId;
315 0 : instr->v1.transLocMSToLocMS.setCKEMask = setCKEMask;
316 0 : instr->v1.transLocMSToLocMS.waitCKEId = waitCKEId;
317 0 : instr->v1.transLocMSToLocMS.waitCKEMask = waitCKEMask;
318 0 : }
319 :
320 : // 远端MS传输到本端MS
321 : // locMSId: 本端MSId
322 : // rmtMSId: 远端MSId
323 : // 数据长度: length
324 : // 路径: channelId
325 0 : void TransRmtMSToLocMSInstr(
326 : CcuInstr* instr, uint16_t locMSId, uint16_t rmtMSId, uint16_t lengthXnId, uint16_t channelId, uint16_t setCKEId,
327 : uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType, uint16_t lengthEn)
328 : {
329 0 : instr->header = InstrHeader(TRANS_TYPE, TRANSRMTMSTOLOCMS_CODE);
330 0 : instr->v1.transRmtMSToLocMS.locMSId = locMSId;
331 0 : instr->v1.transRmtMSToLocMS.rmtMSId = rmtMSId;
332 0 : instr->v1.transRmtMSToLocMS.lengthXnId = lengthXnId;
333 0 : instr->v1.transRmtMSToLocMS.channelId = channelId;
334 0 : instr->v1.transRmtMSToLocMS.clearType = clearType & 0x1;
335 0 : instr->v1.transRmtMSToLocMS.lengthEn = lengthEn & 0x1;
336 0 : instr->v1.transRmtMSToLocMS.setCKEId = setCKEId;
337 0 : instr->v1.transRmtMSToLocMS.setCKEMask = setCKEMask;
338 0 : instr->v1.transRmtMSToLocMS.waitCKEId = waitCKEId;
339 0 : instr->v1.transRmtMSToLocMS.waitCKEMask = waitCKEMask;
340 0 : }
341 :
342 0 : void TransLocMSToRmtMSInstr(
343 : CcuInstr* instr, uint16_t rmtMSId, uint16_t locMSId, uint16_t lengthXnId, uint16_t channelId,
344 : uint16_t setRmtCKEId, uint16_t setRmtCKEMask, uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId,
345 : uint16_t waitCKEMask, uint16_t clearType, uint16_t lengthEn)
346 : {
347 0 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMSTORMTMS_CODE);
348 0 : instr->v1.transLocMSToRmtMS.rmtMSId = rmtMSId;
349 0 : instr->v1.transLocMSToRmtMS.locMSId = locMSId;
350 0 : instr->v1.transLocMSToRmtMS.lengthXnId = lengthXnId;
351 0 : instr->v1.transLocMSToRmtMS.channelId = channelId;
352 0 : instr->v1.transLocMSToRmtMS.setRmtCKEId = setRmtCKEId;
353 0 : instr->v1.transLocMSToRmtMS.setRmtCKEMask = setRmtCKEMask;
354 :
355 0 : instr->v1.transLocMSToRmtMS.clearType = clearType & 0x1;
356 0 : instr->v1.transLocMSToRmtMS.lengthEn = lengthEn & 0x1;
357 0 : instr->v1.transLocMSToRmtMS.setCKEId = setCKEId;
358 0 : instr->v1.transLocMSToRmtMS.setCKEMask = setCKEMask;
359 0 : instr->v1.transLocMSToRmtMS.waitCKEId = waitCKEId;
360 0 : instr->v1.transLocMSToRmtMS.waitCKEMask = waitCKEMask;
361 0 : }
362 :
363 : // 远端Memory传输到本端Memory
364 : // <locGSAId, locXnId>: 本端Memory地址和Token
365 : // <rmtGSAId, rmtXnId>: 远端Memory地址和Token
366 : // 数据长度: length
367 : // 路径: channelId
368 3 : void TransRmtMemToLocMemInstr(
369 : CcuInstr* instr, uint16_t locGSAId, uint16_t locXnId, uint16_t rmtGSAId, uint16_t rmtXnId, uint16_t lengthXnId,
370 : uint16_t channelId, uint16_t reduceDataType, uint16_t reduceOpCode, uint16_t setCKEId, uint16_t setCKEMask,
371 : uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType, uint16_t lengthEn, uint16_t reduceEn)
372 : {
373 3 : instr->header = InstrHeader(TRANS_TYPE, TRANSRMTMEMTOLOCMEM_CODE);
374 3 : instr->v1.transRmtMemToLocMem.locGSAId = locGSAId;
375 3 : instr->v1.transRmtMemToLocMem.locXnId = locXnId;
376 3 : instr->v1.transRmtMemToLocMem.rmtGSAId = rmtGSAId;
377 3 : instr->v1.transRmtMemToLocMem.rmtXnId = rmtXnId;
378 3 : instr->v1.transRmtMemToLocMem.lengthXnId = lengthXnId;
379 3 : instr->v1.transRmtMemToLocMem.channelId = channelId;
380 3 : instr->v1.transRmtMemToLocMem.udfType = 0;
381 3 : instr->v1.transRmtMemToLocMem.reduceDataType = reduceDataType & 0xf;
382 3 : instr->v1.transRmtMemToLocMem.reduceOpCode = reduceOpCode & 0xf;
383 3 : instr->v1.transRmtMemToLocMem.clearType = clearType & 0x1;
384 3 : instr->v1.transRmtMemToLocMem.lengthEn = lengthEn & 0x1;
385 3 : instr->v1.transRmtMemToLocMem.reduceEn = reduceEn & 0x1;
386 3 : instr->v1.transRmtMemToLocMem.setCKEId = setCKEId;
387 3 : instr->v1.transRmtMemToLocMem.setCKEMask = setCKEMask;
388 3 : instr->v1.transRmtMemToLocMem.waitCKEId = waitCKEId;
389 3 : instr->v1.transRmtMemToLocMem.waitCKEMask = waitCKEMask;
390 3 : }
391 :
392 : // 本端Memory传输到远端Memory
393 : // <rmtGSAId, rmtXnId>: 远端Memory地址和Token
394 : // <locGSAId, locXnId>: 本端Memory地址和Token
395 : // 数据长度: length
396 : // 路径: channelId
397 4 : void TransLocMemToRmtMemInstr(
398 : CcuInstr* instr, uint16_t rmtGSAId, uint16_t rmtXnId, uint16_t locGSAId, uint16_t locXnId, uint16_t lengthXnId,
399 : uint16_t channelId, uint16_t reduceDataType, uint16_t reduceOpCode, uint16_t setCKEId, uint16_t setCKEMask,
400 : uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType, uint16_t lengthEn, uint16_t reduceEn)
401 : {
402 4 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMEMTORMTMEM_CODE);
403 4 : instr->v1.transLocMemToRmtMem.rmtGSAId = rmtGSAId;
404 4 : instr->v1.transLocMemToRmtMem.rmtXnId = rmtXnId;
405 4 : instr->v1.transLocMemToRmtMem.locGSAId = locGSAId;
406 4 : instr->v1.transLocMemToRmtMem.locXnId = locXnId;
407 4 : instr->v1.transLocMemToRmtMem.lengthXnId = lengthXnId;
408 4 : instr->v1.transLocMemToRmtMem.channelId = channelId;
409 4 : instr->v1.transLocMemToRmtMem.udfType = 0;
410 4 : instr->v1.transLocMemToRmtMem.reduceDataType = reduceDataType & 0xf;
411 4 : instr->v1.transLocMemToRmtMem.reduceOpCode = reduceOpCode & 0xf;
412 4 : instr->v1.transLocMemToRmtMem.clearType = clearType & 0x1;
413 4 : instr->v1.transLocMemToRmtMem.lengthEn = lengthEn & 0x1;
414 4 : instr->v1.transLocMemToRmtMem.reduceEn = reduceEn & 0x1;
415 4 : instr->v1.transLocMemToRmtMem.setCKEId = setCKEId;
416 4 : instr->v1.transLocMemToRmtMem.setCKEMask = setCKEMask;
417 4 : instr->v1.transLocMemToRmtMem.waitCKEId = waitCKEId;
418 4 : instr->v1.transLocMemToRmtMem.waitCKEMask = waitCKEMask;
419 4 : }
420 :
421 14 : void TransLocMemToLocMemInstr(
422 : CcuInstr* instr, uint16_t dstGSAId, uint16_t dstXnId, uint16_t srcGSAId, uint16_t srcXnId, uint16_t lengthXnId,
423 : uint16_t channelId, uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask,
424 : uint16_t clearType, uint16_t lengthEn)
425 : {
426 14 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMEMTOLOCMEM_CODE);
427 14 : instr->v1.transLocMemToLocMem.dstGSAId = dstGSAId;
428 14 : instr->v1.transLocMemToLocMem.dstXnId = dstXnId;
429 14 : instr->v1.transLocMemToLocMem.srcGSAId = srcGSAId;
430 14 : instr->v1.transLocMemToLocMem.srcXnId = srcXnId;
431 14 : instr->v1.transLocMemToLocMem.lengthXnId = lengthXnId;
432 14 : instr->v1.transLocMemToLocMem.channelId = channelId;
433 14 : instr->v1.transLocMemToLocMem.clearType = clearType & 0x1;
434 14 : instr->v1.transLocMemToLocMem.lengthEn = lengthEn & 0x1;
435 14 : instr->v1.transLocMemToLocMem.setCKEId = setCKEId;
436 14 : instr->v1.transLocMemToLocMem.setCKEMask = setCKEMask;
437 14 : instr->v1.transLocMemToLocMem.waitCKEId = waitCKEId;
438 14 : instr->v1.transLocMemToLocMem.waitCKEMask = waitCKEMask;
439 14 : }
440 :
441 : // 本端CKE同步到远端CKE
442 : // rmtCKEId: 远端CKEId
443 : // locCKEId: 本端CKEId
444 : // locCKEMask: mask
445 : // 路径: channelId
446 3 : void SyncCKEInstr(
447 : CcuInstr* instr, uint16_t rmtCKEId, uint16_t locCKEId, uint16_t locCKEMask, uint16_t channelId,
448 : uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType)
449 : {
450 3 : instr->header = InstrHeader(TRANS_TYPE, SYNCCKE_CODE);
451 3 : instr->v1.syncCKE.rmtCKEId = rmtCKEId;
452 3 : instr->v1.syncCKE.locCKEId = locCKEId;
453 3 : instr->v1.syncCKE.locCKEMask = locCKEMask;
454 3 : instr->v1.syncCKE.channelId = channelId;
455 3 : instr->v1.syncCKE.clearType = clearType & 0x1;
456 3 : instr->v1.syncCKE.setCKEId = setCKEId;
457 3 : instr->v1.syncCKE.setCKEMask = setCKEMask;
458 3 : instr->v1.syncCKE.waitCKEId = waitCKEId;
459 3 : instr->v1.syncCKE.waitCKEMask = waitCKEMask;
460 3 : }
461 :
462 : // 本端<locGSAId>同步到远端<rmtGSAId> 同步完成后, 置位远端的<setRmtCKEId, setRmtCKEMask>
463 0 : void SyncGSAInstr(
464 : CcuInstr* instr, uint16_t rmtGSAId, uint16_t locGSAId, uint16_t channelId, uint16_t setRmtCKEId,
465 : uint16_t setRmtCKEMask, uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask,
466 : uint16_t clearType)
467 : {
468 0 : instr->header = InstrHeader(TRANS_TYPE, SYNCGSA_CODE);
469 0 : instr->v1.syncGSA.rmtGSAId = rmtGSAId;
470 0 : instr->v1.syncGSA.locGSAId = locGSAId;
471 0 : instr->v1.syncGSA.channelId = channelId;
472 0 : instr->v1.syncGSA.setRmtCKEId = setRmtCKEId;
473 0 : instr->v1.syncGSA.setRmtCKEMask = setRmtCKEMask;
474 0 : instr->v1.syncGSA.clearType = clearType & 0x1;
475 0 : instr->v1.syncGSA.setCKEId = setCKEId;
476 0 : instr->v1.syncGSA.setCKEMask = setCKEMask;
477 0 : instr->v1.syncGSA.waitCKEId = waitCKEId;
478 0 : instr->v1.syncGSA.waitCKEMask = waitCKEMask;
479 0 : }
480 :
481 : // 本端<locInputXnId, locOutputXnId>同步到远端<rmtInputXnId, rmtOutputXnId> 同步完成后, 置位远端的<setRmtCKEId,
482 : // setRmtCKEMask>
483 5 : void SyncXnInstr(
484 : CcuInstr* instr, uint16_t rmtXnId, uint16_t locXnId, uint16_t channelId, uint16_t setRmtCKEId,
485 : uint16_t setRmtCKEMask, uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask,
486 : uint16_t clearType)
487 : {
488 5 : instr->header = InstrHeader(TRANS_TYPE, SYNCXN_CODE);
489 5 : instr->v1.syncXn.rmtXnId = rmtXnId;
490 5 : instr->v1.syncXn.locXnId = locXnId;
491 5 : instr->v1.syncXn.channelId = channelId;
492 5 : instr->v1.syncXn.setRmtCKEId = setRmtCKEId;
493 5 : instr->v1.syncXn.setRmtCKEMask = setRmtCKEMask;
494 5 : instr->v1.syncXn.clearType = clearType & 0x1;
495 5 : instr->v1.syncXn.setCKEId = setCKEId;
496 5 : instr->v1.syncXn.setCKEMask = setCKEMask;
497 5 : instr->v1.syncXn.waitCKEId = waitCKEId;
498 5 : instr->v1.syncXn.waitCKEMask = waitCKEMask;
499 5 : }
500 :
501 : // MSA~MSH Reduce到 MSA
502 : // count: 参与Reduce的MS数目
503 : // castEn: 输出是否截断
504 : // dataType: Reduce数据类型
505 4 : void AddInstr(
506 : CcuInstr* instr, uint16_t* msId, uint16_t count, uint16_t castEn, uint16_t dataType, uint16_t setCKEId,
507 : uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType, uint16_t XnIdLength)
508 : {
509 4 : count -= 2; // CCU指令中指定count数为实际参与运算的MS数减2
510 4 : instr->header = InstrHeader(REDUCE_TYPE, ADD_CODE);
511 36 : for (uint16_t index = 0; index < CCU_REDUCE_MAX_MS; index++) {
512 32 : instr->v1.add.msId[index] = msId[index];
513 : }
514 4 : instr->v1.add.XnIdLength = XnIdLength;
515 4 : instr->v1.add.count = count & 0x7;
516 4 : instr->v1.add.castEn = castEn & 0x3;
517 4 : instr->v1.add.dataType = dataType & 0x1f;
518 4 : instr->v1.add.clearType = clearType & 0x1;
519 4 : instr->v1.add.setCKEId = setCKEId;
520 4 : instr->v1.add.setCKEMask = setCKEMask;
521 4 : instr->v1.add.waitCKEId = waitCKEId;
522 4 : instr->v1.add.waitCKEMask = waitCKEMask;
523 4 : }
524 :
525 1 : void MaxInstr(
526 : CcuInstr* instr, uint16_t* msId, uint16_t count, uint16_t dataType, uint16_t setCKEId, uint16_t setCKEMask,
527 : uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType, uint16_t XnIdLength)
528 : {
529 1 : count -= 2; // CCU指令中指定count数为实际参与运算的MS数减2
530 1 : instr->header = InstrHeader(REDUCE_TYPE, MAX_CODE);
531 9 : for (uint16_t index = 0; index < CCU_REDUCE_MAX_MS; index++) {
532 8 : instr->v1.add.msId[index] = msId[index];
533 : }
534 1 : instr->v1.max.XnIdLength = XnIdLength;
535 1 : instr->v1.max.count = count & 0x7;
536 1 : instr->v1.max.dataType = dataType & 0x1f;
537 1 : instr->v1.max.clearType = clearType & 0x1;
538 1 : instr->v1.max.setCKEId = setCKEId;
539 1 : instr->v1.max.setCKEMask = setCKEMask;
540 1 : instr->v1.max.waitCKEId = waitCKEId;
541 1 : instr->v1.max.waitCKEMask = waitCKEMask;
542 1 : }
543 :
544 1 : void MinInstr(
545 : CcuInstr* instr, uint16_t* msId, uint16_t count, uint16_t dataType, uint16_t setCKEId, uint16_t setCKEMask,
546 : uint16_t waitCKEId, uint16_t waitCKEMask, uint16_t clearType, uint16_t XnIdLength)
547 : {
548 1 : count -= 2; // CCU指令中指定count数为实际参与运算的MS数减2
549 1 : instr->header = InstrHeader(REDUCE_TYPE, MIN_CODE);
550 9 : for (uint16_t index = 0; index < CCU_REDUCE_MAX_MS; index++) {
551 8 : instr->v1.add.msId[index] = msId[index];
552 : }
553 1 : instr->v1.max.XnIdLength = XnIdLength;
554 1 : instr->v1.min.count = count & 0x7;
555 1 : instr->v1.min.dataType = dataType & 0x1f;
556 1 : instr->v1.min.clearType = clearType & 0x1;
557 1 : instr->v1.min.setCKEId = setCKEId;
558 1 : instr->v1.min.setCKEMask = setCKEMask;
559 1 : instr->v1.min.waitCKEId = waitCKEId;
560 1 : instr->v1.min.waitCKEMask = waitCKEMask;
561 1 : }
562 :
563 0 : std::string ParseLoadSqeArgsToGSAInstr(const CcuInstr* instr)
564 : {
565 0 : uint16_t gsaId = instr->v1.loadSqeArgsToGSA.gsaId;
566 0 : uint16_t sqeArgsId = instr->v1.loadSqeArgsToGSA.sqeArgsId;
567 :
568 0 : return Hccl::StringFormat("Load SqeArg[%u] to GSA[%u]", sqeArgsId, gsaId);
569 : }
570 :
571 64 : static std::string ParseLoadSqeArgsToXnInstr(const CcuInstr* instr)
572 : {
573 64 : uint16_t xnId = instr->v1.loadSqeArgsToXn.xnId;
574 64 : uint16_t sqeArgsId = instr->v1.loadSqeArgsToXn.sqeArgsId;
575 :
576 64 : return Hccl::StringFormat("Load SqeArg[%u] to Xn[%u]", sqeArgsId, xnId);
577 : }
578 :
579 69 : static std::string ParseLoadImdToGSAInstr(const CcuInstr* instr)
580 : {
581 69 : uint16_t gsaId = instr->v1.loadImdToGSA.gsaId;
582 69 : uint64_t immediate = instr->v1.loadImdToGSA.immediate;
583 :
584 69 : return Hccl::StringFormat("Load immediate[%llu] to GSA[%u]", immediate, gsaId);
585 : }
586 :
587 1104 : static std::string ParseLoadImdToXnInstr(const CcuInstr* instr)
588 : {
589 1104 : uint16_t xnId = instr->v1.loadImdToXn.xnId;
590 1104 : uint64_t immediate = instr->v1.loadImdToXn.immediate;
591 :
592 1104 : if (instr->v1.loadImdToXn.secFlag == CCU_LOAD_TO_XN_SEC_INFO) {
593 32 : return Hccl::StringFormat("Load immediate[tokenInfo] to Xn[%u]", xnId);
594 : }
595 :
596 1072 : return Hccl::StringFormat("Load immediate[%llu] to Xn[%u]", immediate, xnId);
597 : }
598 :
599 78 : static std::string ParseLoadGSAXnInstr(const CcuInstr* instr)
600 : {
601 78 : uint16_t gsAdId = instr->v1.loadGSAXn.gsAdId;
602 78 : uint16_t gsAmId = instr->v1.loadGSAXn.gsAmId;
603 78 : uint16_t xnId = instr->v1.loadGSAXn.xnId;
604 :
605 78 : return Hccl::StringFormat("Load GSA[%u] + Xn[%u] to GSA[%u]", gsAmId, xnId, gsAdId);
606 : }
607 :
608 46 : static std::string ParseLoadGSAGSAInstr(const CcuInstr* instr)
609 : {
610 46 : uint16_t gsAdId = instr->v1.loadGSAGSA.gsAdId;
611 46 : uint16_t gsAmId = instr->v1.loadGSAGSA.gsAmId;
612 46 : uint16_t gsAnId = instr->v1.loadGSAGSA.gsAnId;
613 :
614 46 : return Hccl::StringFormat("Load GSA[%u] + GSA[%u] to GSA[%u]", gsAmId, gsAnId, gsAdId);
615 : }
616 :
617 414 : static std::string ParseLoadXXInstr(const CcuInstr* instr)
618 : {
619 414 : uint16_t xdId = instr->v1.loadXX.xdId;
620 414 : uint16_t xmId = instr->v1.loadXX.xmId;
621 414 : uint16_t xnId = instr->v1.loadXX.xnId;
622 :
623 414 : return Hccl::StringFormat("Load Xn[%u] + Xn[%u] to Xn[%u]", xmId, xnId, xdId);
624 : }
625 :
626 72 : static std::string ParseLoopInstr(const CcuInstr* instr)
627 : {
628 72 : uint16_t startInstrId = instr->v1.loop.startInstrId;
629 72 : uint16_t endInstrId = instr->v1.loop.endInstrId;
630 72 : uint16_t xnId = instr->v1.loop.xnId;
631 :
632 : return Hccl::StringFormat(
633 72 : "Loop From startInstrId[%u] to endInstrId[%u] with loopXn[%u]", startInstrId, endInstrId, xnId);
634 : }
635 :
636 36 : static std::string ParseLoopGroupInstr(const CcuInstr* instr)
637 : {
638 36 : uint16_t startLoopInstrId = instr->v1.loopGroup.startLoopInstrId;
639 36 : uint16_t xnId = instr->v1.loopGroup.xnId;
640 36 : uint16_t xmId = instr->v1.loopGroup.xmId;
641 36 : uint16_t highPerfModeEn = instr->v1.loopGroup.highPerfModeEn;
642 :
643 : return Hccl::StringFormat(
644 : "LoopGroup From startLoopInstrId[%u] with loopGroupXn[%u], offsetXn[%u] and highPerfModeEn[%u]",
645 36 : startLoopInstrId, xnId, xmId, highPerfModeEn);
646 : }
647 :
648 111 : static std::string ParseSetCKEInstr(const CcuInstr* instr)
649 : {
650 111 : uint16_t clearType = instr->v1.setCKE.clearType;
651 111 : uint16_t setCKEId = instr->v1.setCKE.setCKEId;
652 111 : uint16_t setCKEMask = instr->v1.setCKE.setCKEMask;
653 111 : uint16_t waitCKEId = instr->v1.setCKE.waitCKEId;
654 111 : uint16_t waitCKEMask = instr->v1.setCKE.waitCKEMask;
655 :
656 : return Hccl::StringFormat(
657 : "Wait CKE[%u:%04x], Set CKE[%u:%04x], clearType[%u]", waitCKEId, waitCKEMask, setCKEId, setCKEMask,
658 111 : clearType);
659 : }
660 :
661 20 : static std::string ParseClearCKEInstr(const CcuInstr* instr)
662 : {
663 20 : uint16_t clearType = instr->v1.clearCKE.clearType;
664 20 : uint16_t clearCKEId = instr->v1.clearCKE.clearCKEId;
665 20 : uint16_t clearMask = instr->v1.clearCKE.clearMask;
666 20 : uint16_t waitCKEId = instr->v1.clearCKE.waitCKEId;
667 20 : uint16_t waitCKEMask = instr->v1.clearCKE.waitCKEMask;
668 :
669 : return Hccl::StringFormat(
670 : "Wait CKE[%u:%04x], Clear CKE[%u:%04x], clearType[%u]", waitCKEId, waitCKEMask, clearCKEId, clearMask,
671 20 : clearType);
672 : }
673 :
674 282 : static std::string ParseJumpInstr(const CcuInstr* instr)
675 : {
676 282 : uint16_t dstInstrXnId = instr->v1.jmp.dstInstrXnId;
677 282 : uint16_t conditionXnId = instr->v1.jmp.conditionXnId;
678 282 : uint64_t expectData = instr->v1.jmp.expectData;
679 :
680 : return Hccl::StringFormat(
681 : "When conditionXn[%u] not equal to expectData[%llu], Jump To InstrIdXn[%u]", conditionXnId, expectData,
682 282 : dstInstrXnId);
683 : }
684 :
685 16 : static std::string ParseTransLocMemToLocMSInstr(const CcuInstr* instr)
686 : {
687 16 : uint16_t locMSId = instr->v1.transLocMemToLocMS.locMSId;
688 16 : uint16_t locGSAId = instr->v1.transLocMemToLocMS.locGSAId;
689 16 : uint16_t locXnId = instr->v1.transLocMemToLocMS.locXnId;
690 16 : uint16_t lengthXnId = instr->v1.transLocMemToLocMS.lengthXnId;
691 16 : uint16_t channelId = instr->v1.transLocMemToLocMS.channelId;
692 16 : uint16_t clearType = instr->v1.transLocMemToLocMS.clearType;
693 16 : uint16_t lengthEn = instr->v1.transLocMemToLocMS.lengthEn;
694 16 : uint16_t setCKEId = instr->v1.transLocMemToLocMS.setCKEId;
695 16 : uint16_t setCKEMask = instr->v1.transLocMemToLocMS.setCKEMask;
696 16 : uint16_t waitCKEId = instr->v1.transLocMemToLocMS.waitCKEId;
697 16 : uint16_t waitCKEMask = instr->v1.transLocMemToLocMS.waitCKEMask;
698 :
699 : return Hccl::StringFormat(
700 : "Wait CKE[%u:%04x], Trans LocMem[%u:%u] To LocMS[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
701 : "CKE[%u:%04x], clearType[%u], lengthEn[%u]",
702 16 : waitCKEId, waitCKEMask, locGSAId, locXnId, locMSId / 0x8000, locMSId % 0x8000, lengthXnId, channelId,
703 16 : setCKEId, setCKEMask, clearType, lengthEn);
704 : }
705 :
706 2 : static std::string ParseTransRmtMemToLocMSInstr(const CcuInstr* instr)
707 : {
708 2 : uint16_t locMSId = instr->v1.transRmtMemToLocMS.locMSId;
709 2 : uint16_t rmtGSAId = instr->v1.transRmtMemToLocMS.rmtGSAId;
710 2 : uint16_t rmtXnId = instr->v1.transRmtMemToLocMS.rmtXnId;
711 2 : uint16_t lengthXnId = instr->v1.transRmtMemToLocMS.lengthXnId;
712 2 : uint16_t channelId = instr->v1.transRmtMemToLocMS.channelId;
713 2 : uint16_t clearType = instr->v1.transRmtMemToLocMS.clearType;
714 2 : uint16_t lengthEn = instr->v1.transRmtMemToLocMS.lengthEn;
715 2 : uint16_t setCKEId = instr->v1.transRmtMemToLocMS.setCKEId;
716 2 : uint16_t setCKEMask = instr->v1.transRmtMemToLocMS.setCKEMask;
717 2 : uint16_t waitCKEId = instr->v1.transRmtMemToLocMS.waitCKEId;
718 2 : uint16_t waitCKEMask = instr->v1.transRmtMemToLocMS.waitCKEMask;
719 :
720 : return Hccl::StringFormat(
721 : "Wait CKE[%u:%04x], Trans RmtMem[%u:%u] To LocMS[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
722 : "CKE[%u:%04x], clearType[%u], lengthEn[%u]",
723 2 : waitCKEId, waitCKEMask, rmtGSAId, rmtXnId, locMSId / 0x8000, locMSId % 0x8000, lengthXnId, channelId,
724 2 : setCKEId, setCKEMask, clearType, lengthEn);
725 : }
726 :
727 12 : static std::string ParseTransLocMSToLocMemInstr(const CcuInstr* instr)
728 : {
729 12 : uint16_t locGSAId = instr->v1.transLocMSToLocMem.locGSAId;
730 12 : uint16_t locXnId = instr->v1.transLocMSToLocMem.locXnId;
731 12 : uint16_t locMSId = instr->v1.transLocMSToLocMem.locMSId;
732 12 : uint16_t lengthXnId = instr->v1.transLocMSToLocMem.lengthXnId;
733 12 : uint16_t channelId = instr->v1.transLocMSToLocMem.channelId;
734 12 : uint16_t clearType = instr->v1.transLocMSToLocMem.clearType;
735 12 : uint16_t lengthEn = instr->v1.transLocMSToLocMem.lengthEn;
736 12 : uint16_t setCKEId = instr->v1.transLocMSToLocMem.setCKEId;
737 12 : uint16_t setCKEMask = instr->v1.transLocMSToLocMem.setCKEMask;
738 12 : uint16_t waitCKEId = instr->v1.transLocMSToLocMem.waitCKEId;
739 12 : uint16_t waitCKEMask = instr->v1.transLocMSToLocMem.waitCKEMask;
740 :
741 : return Hccl::StringFormat(
742 : "Wait CKE[%u:%04x], Trans LocMS[%u:%u] To LocMem[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
743 : "CKE[%u:%04x], clearType[%u], lengthEn[%u]",
744 12 : waitCKEId, waitCKEMask, locMSId / 0x8000, locMSId % 0x8000, locGSAId, locXnId, lengthXnId, channelId,
745 12 : setCKEId, setCKEMask, clearType, lengthEn);
746 : }
747 :
748 2 : static std::string ParseTransLocMSToRmtMemInstr(const CcuInstr* instr)
749 : {
750 2 : uint16_t rmtGSAId = instr->v1.transLocMSToRmtMem.rmtGSAId;
751 2 : uint16_t rmtXnId = instr->v1.transLocMSToRmtMem.rmtXnId;
752 2 : uint16_t locMSId = instr->v1.transLocMSToRmtMem.locMSId;
753 2 : uint16_t lengthXnId = instr->v1.transLocMSToRmtMem.lengthXnId;
754 2 : uint16_t channelId = instr->v1.transLocMSToRmtMem.channelId;
755 2 : uint16_t clearType = instr->v1.transLocMSToRmtMem.clearType;
756 2 : uint16_t lengthEn = instr->v1.transLocMSToRmtMem.lengthEn;
757 2 : uint16_t setCKEId = instr->v1.transLocMSToRmtMem.setCKEId;
758 2 : uint16_t setCKEMask = instr->v1.transLocMSToRmtMem.setCKEMask;
759 2 : uint16_t waitCKEId = instr->v1.transLocMSToRmtMem.waitCKEId;
760 2 : uint16_t waitCKEMask = instr->v1.transLocMSToRmtMem.waitCKEMask;
761 :
762 : return Hccl::StringFormat(
763 : "Wait CKE[%u:%04x], Trans LocMS[%u:%u] To RmtMem[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
764 : "CKE[%u:%04x], clearType[%u], lengthEn[%u]",
765 2 : waitCKEId, waitCKEMask, locMSId / 0x8000, locMSId % 0x8000, rmtGSAId, rmtXnId, lengthXnId, channelId,
766 2 : setCKEId, setCKEMask, clearType, lengthEn);
767 : }
768 :
769 0 : static std::string ParseTransRmtMSToLocMemInstr(const CcuInstr* instr)
770 : {
771 0 : uint16_t locGSAId = instr->v1.transRmtMSToLocMem.locGSAId;
772 0 : uint16_t locXnId = instr->v1.transRmtMSToLocMem.locXnId;
773 0 : uint16_t rmtMSId = instr->v1.transRmtMSToLocMem.rmtMSId;
774 0 : uint16_t lengthXnId = instr->v1.transRmtMSToLocMem.lengthXnId;
775 0 : uint16_t channelId = instr->v1.transRmtMSToLocMem.channelId;
776 0 : uint16_t clearType = instr->v1.transRmtMSToLocMem.clearType;
777 0 : uint16_t lengthEn = instr->v1.transRmtMSToLocMem.lengthEn;
778 0 : uint16_t setCKEId = instr->v1.transRmtMSToLocMem.setCKEId;
779 0 : uint16_t setCKEMask = instr->v1.transRmtMSToLocMem.setCKEMask;
780 0 : uint16_t waitCKEId = instr->v1.transRmtMSToLocMem.waitCKEId;
781 0 : uint16_t waitCKEMask = instr->v1.transRmtMSToLocMem.waitCKEMask;
782 :
783 : return Hccl::StringFormat(
784 : "Wait CKE[%u:%04x], Trans RmtMS[%u:%u] To LocMem[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
785 : "CKE[%u:%04x], clearType[%u], lengthEn[%u]",
786 0 : waitCKEId, waitCKEMask, rmtMSId / 0x8000, rmtMSId % 0x8000, locGSAId, locXnId, lengthXnId, channelId,
787 0 : setCKEId, setCKEMask, clearType, lengthEn);
788 : }
789 :
790 0 : static std::string ParseTransLocMSToLocMSInstr(const CcuInstr* instr)
791 : {
792 0 : uint16_t dstMSId = instr->v1.transLocMSToLocMS.dstMSId;
793 0 : uint16_t srcMSId = instr->v1.transLocMSToLocMS.srcMSId;
794 0 : uint16_t lengthXnId = instr->v1.transLocMSToLocMS.lengthXnId;
795 0 : uint16_t channelId = instr->v1.transLocMSToLocMS.channelId;
796 0 : uint16_t clearType = instr->v1.transLocMSToLocMS.clearType;
797 0 : uint16_t lengthEn = instr->v1.transLocMSToLocMS.lengthEn;
798 0 : uint16_t setCKEId = instr->v1.transLocMSToLocMS.setCKEId;
799 0 : uint16_t setCKEMask = instr->v1.transLocMSToLocMS.setCKEMask;
800 0 : uint16_t waitCKEId = instr->v1.transLocMSToLocMS.waitCKEId;
801 0 : uint16_t waitCKEMask = instr->v1.transLocMSToLocMS.waitCKEMask;
802 :
803 : return Hccl::StringFormat(
804 : "Wait CKE[%u:%04x], Trans LocMS[%u:%u] To LocMS[%u:%u] With LengthXn[%u] Use Channel[%u], "
805 : "Set CKE[%u:%04x], "
806 : "clearType[%u], lengthEn[%u]",
807 0 : waitCKEId, waitCKEMask, srcMSId / 0x8000, srcMSId % 0x8000, dstMSId / 0x8000, dstMSId % 0x8000, lengthXnId,
808 0 : channelId, setCKEId, setCKEMask, clearType, lengthEn);
809 : }
810 :
811 0 : static std::string ParseTransRmtMSToLocMSInstr(const CcuInstr* instr)
812 : {
813 0 : uint16_t locMSId = instr->v1.transRmtMSToLocMS.locMSId;
814 0 : uint16_t rmtMSId = instr->v1.transRmtMSToLocMS.rmtMSId;
815 0 : uint16_t lengthXnId = instr->v1.transRmtMSToLocMS.lengthXnId;
816 0 : uint16_t channelId = instr->v1.transRmtMSToLocMS.channelId;
817 0 : uint16_t clearType = instr->v1.transRmtMSToLocMS.clearType;
818 0 : uint16_t lengthEn = instr->v1.transRmtMSToLocMS.lengthEn;
819 0 : uint16_t setCKEId = instr->v1.transRmtMSToLocMS.setCKEId;
820 0 : uint16_t setCKEMask = instr->v1.transRmtMSToLocMS.setCKEMask;
821 0 : uint16_t waitCKEId = instr->v1.transRmtMSToLocMS.waitCKEId;
822 0 : uint16_t waitCKEMask = instr->v1.transRmtMSToLocMS.waitCKEMask;
823 :
824 : return Hccl::StringFormat(
825 : "Wait CKE[%u:%04x], Trans RmtMS[%u:%u] To LocMS[%u:%u] With LengthXn[%u] Use Channel[%u], "
826 : "Set CKE[%u:%04x], "
827 : "clearType[%u], lengthEn[%u]",
828 0 : waitCKEId, waitCKEMask, rmtMSId / 0x8000, rmtMSId % 0x8000, locMSId / 0x8000, locMSId % 0x8000, lengthXnId,
829 0 : channelId, setCKEId, setCKEMask, clearType, lengthEn);
830 : }
831 :
832 0 : static std::string ParseTransLocMSToRmtMSInstr(const CcuInstr* instr)
833 : {
834 0 : uint16_t rmtMSId = instr->v1.transLocMSToRmtMS.rmtMSId;
835 0 : uint16_t locMSId = instr->v1.transLocMSToRmtMS.locMSId;
836 0 : uint16_t lengthXnId = instr->v1.transLocMSToRmtMS.lengthXnId;
837 0 : uint16_t channelId = instr->v1.transLocMSToRmtMS.channelId;
838 0 : uint16_t setRmtCKEId = instr->v1.transLocMSToRmtMS.setRmtCKEId;
839 0 : uint16_t setRmtCKEMask = instr->v1.transLocMSToRmtMS.setRmtCKEMask;
840 :
841 0 : uint16_t clearType = instr->v1.transLocMSToRmtMS.clearType;
842 0 : uint16_t lengthEn = instr->v1.transLocMSToRmtMS.lengthEn;
843 0 : uint16_t setCKEId = instr->v1.transLocMSToRmtMS.setCKEId;
844 0 : uint16_t setCKEMask = instr->v1.transLocMSToRmtMS.setCKEMask;
845 0 : uint16_t waitCKEId = instr->v1.transLocMSToRmtMS.waitCKEId;
846 0 : uint16_t waitCKEMask = instr->v1.transLocMSToRmtMS.waitCKEMask;
847 :
848 : return Hccl::StringFormat(
849 : "Wait CKE[%u:%04x], Trans LocMS[%u:%u] To RmtMS[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
850 : "RmtCKE[%u:%04x], Set CKE[%u:%04x], clearType[%u], lengthEn[%u]",
851 0 : waitCKEId, waitCKEMask, locMSId / 0x8000, locMSId % 0x8000, rmtMSId / 0x8000, rmtMSId % 0x8000, lengthXnId,
852 0 : channelId, setRmtCKEId, setRmtCKEMask, setCKEId, setCKEMask, clearType, lengthEn);
853 : }
854 :
855 6 : static std::string ParseTransRmtMemToLocMemInstr(const CcuInstr* instr)
856 : {
857 6 : uint16_t locGSAId = instr->v1.transRmtMemToLocMem.locGSAId;
858 6 : uint16_t locXnId = instr->v1.transRmtMemToLocMem.locXnId;
859 6 : uint16_t rmtGSAId = instr->v1.transRmtMemToLocMem.rmtGSAId;
860 6 : uint16_t rmtXnId = instr->v1.transRmtMemToLocMem.rmtXnId;
861 6 : uint16_t lengthXnId = instr->v1.transRmtMemToLocMem.lengthXnId;
862 6 : uint16_t channelId = instr->v1.transRmtMemToLocMem.channelId;
863 6 : uint16_t reduceDataType = instr->v1.transRmtMemToLocMem.reduceDataType;
864 6 : uint16_t reduceOpCode = instr->v1.transRmtMemToLocMem.reduceOpCode;
865 6 : uint16_t clearType = instr->v1.transRmtMemToLocMem.clearType;
866 6 : uint16_t lengthEn = instr->v1.transRmtMemToLocMem.lengthEn;
867 6 : uint16_t reduceEn = instr->v1.transRmtMemToLocMem.reduceEn;
868 6 : uint16_t setCKEId = instr->v1.transRmtMemToLocMem.setCKEId;
869 6 : uint16_t setCKEMask = instr->v1.transRmtMemToLocMem.setCKEMask;
870 6 : uint16_t waitCKEId = instr->v1.transRmtMemToLocMem.waitCKEId;
871 6 : uint16_t waitCKEMask = instr->v1.transRmtMemToLocMem.waitCKEMask;
872 :
873 : return Hccl::StringFormat(
874 : "Wait CKE[%u:%04x], Trans RmtMem[%u:%u] To LocMem[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
875 : "CKE[%u:%04x], clearType[%u], lengthEn[%u], DataType[%u], ReduceType[%u] reduceEn[%u]",
876 : waitCKEId, waitCKEMask, rmtGSAId, rmtXnId, locGSAId, locXnId, lengthXnId, channelId, setCKEId, setCKEMask,
877 6 : clearType, lengthEn, reduceDataType, reduceOpCode, reduceEn);
878 : }
879 :
880 6 : static std::string ParseTransLocMemToRmtMemInstr(const CcuInstr* instr)
881 : {
882 6 : uint16_t rmtGSAId = instr->v1.transLocMemToRmtMem.rmtGSAId;
883 6 : uint16_t rmtXnId = instr->v1.transLocMemToRmtMem.rmtXnId;
884 6 : uint16_t locGSAId = instr->v1.transLocMemToRmtMem.locGSAId;
885 6 : uint16_t locXnId = instr->v1.transLocMemToRmtMem.locXnId;
886 6 : uint16_t lengthXnId = instr->v1.transLocMemToRmtMem.lengthXnId;
887 6 : uint16_t channelId = instr->v1.transLocMemToRmtMem.channelId;
888 6 : uint16_t reduceDataType = instr->v1.transLocMemToRmtMem.reduceDataType;
889 6 : uint16_t reduceOpCode = instr->v1.transLocMemToRmtMem.reduceOpCode;
890 6 : uint16_t clearType = instr->v1.transLocMemToRmtMem.clearType;
891 6 : uint16_t lengthEn = instr->v1.transLocMemToRmtMem.lengthEn;
892 6 : uint16_t reduceEn = instr->v1.transLocMemToRmtMem.reduceEn;
893 6 : uint16_t setCKEId = instr->v1.transLocMemToRmtMem.setCKEId;
894 6 : uint16_t setCKEMask = instr->v1.transLocMemToRmtMem.setCKEMask;
895 6 : uint16_t waitCKEId = instr->v1.transLocMemToRmtMem.waitCKEId;
896 6 : uint16_t waitCKEMask = instr->v1.transLocMemToRmtMem.waitCKEMask;
897 :
898 : return Hccl::StringFormat(
899 : "Wait CKE[%u:%04x], Trans LocMem[%u:%u] To RmtMem[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
900 : "CKE[%u:%04x], clearType[%u], lengthEn[%u], DataType[%u], ReduceType[%u] reduceEn[%u]",
901 : waitCKEId, waitCKEMask, locGSAId, locXnId, rmtGSAId, rmtXnId, lengthXnId, channelId, setCKEId, setCKEMask,
902 6 : clearType, lengthEn, reduceDataType, reduceOpCode, reduceEn);
903 : }
904 :
905 18 : static std::string ParseTransLocMemToLocMemInstr(const CcuInstr* instr)
906 : {
907 18 : uint16_t dstGSAId = instr->v1.transLocMemToLocMem.dstGSAId;
908 18 : uint16_t dstXnId = instr->v1.transLocMemToLocMem.dstXnId;
909 18 : uint16_t srcGSAId = instr->v1.transLocMemToLocMem.srcGSAId;
910 18 : uint16_t srcXnId = instr->v1.transLocMemToLocMem.srcXnId;
911 18 : uint16_t lengthXnId = instr->v1.transLocMemToLocMem.lengthXnId;
912 18 : uint16_t channelId = instr->v1.transLocMemToLocMem.channelId;
913 18 : uint16_t clearType = instr->v1.transLocMemToLocMem.clearType;
914 18 : uint16_t lengthEn = instr->v1.transLocMemToLocMem.lengthEn;
915 18 : uint16_t setCKEId = instr->v1.transLocMemToLocMem.setCKEId;
916 18 : uint16_t setCKEMask = instr->v1.transLocMemToLocMem.setCKEMask;
917 18 : uint16_t waitCKEId = instr->v1.transLocMemToLocMem.waitCKEId;
918 18 : uint16_t waitCKEMask = instr->v1.transLocMemToLocMem.waitCKEMask;
919 :
920 : return Hccl::StringFormat(
921 : "Wait CKE[%u:%04x], Trans LocMem[%u:%u] To LocMem[%u:%u] With LengthXn[%u] Use Channel[%u], Set "
922 : "CKE[%u:%04x], clearType[%u], lengthEn[%u]",
923 : waitCKEId, waitCKEMask, srcGSAId, srcXnId, dstGSAId, dstXnId, lengthXnId, channelId, setCKEId, setCKEMask,
924 18 : clearType, lengthEn);
925 : }
926 :
927 4 : static std::string ParseSyncCKEInstr(const CcuInstr* instr)
928 : {
929 4 : uint16_t rmtCKEId = instr->v1.syncCKE.rmtCKEId;
930 4 : uint16_t locCKEId = instr->v1.syncCKE.locCKEId;
931 4 : uint16_t locCKEMask = instr->v1.syncCKE.locCKEMask;
932 4 : uint16_t channelId = instr->v1.syncCKE.channelId;
933 4 : uint16_t clearType = instr->v1.syncCKE.clearType;
934 4 : uint16_t setCKEId = instr->v1.syncCKE.setCKEId;
935 4 : uint16_t setCKEMask = instr->v1.syncCKE.setCKEMask;
936 4 : uint16_t waitCKEId = instr->v1.syncCKE.waitCKEId;
937 4 : uint16_t waitCKEMask = instr->v1.syncCKE.waitCKEMask;
938 :
939 : return Hccl::StringFormat(
940 : "Wait CKE[%u:%04x], Sync LocCKE[%u:%04x] To rmtCKE[%u:%04x] Use Channel[%u], Set "
941 : "CKE[%u:%04x], clearType[%u]",
942 : waitCKEId, waitCKEMask, locCKEId, locCKEMask, rmtCKEId, locCKEMask, channelId, setCKEId, setCKEMask,
943 4 : clearType);
944 : }
945 :
946 0 : static std::string ParseSyncGSAInstr(const CcuInstr* instr)
947 : {
948 0 : uint16_t rmtGSAId = instr->v1.syncGSA.rmtGSAId;
949 0 : uint16_t locGSAId = instr->v1.syncGSA.locGSAId;
950 0 : uint16_t channelId = instr->v1.syncGSA.channelId;
951 0 : uint16_t setRmtCKEId = instr->v1.syncGSA.setRmtCKEId;
952 0 : uint16_t setRmtCKEMask = instr->v1.syncGSA.setRmtCKEMask;
953 0 : uint16_t clearType = instr->v1.syncGSA.clearType;
954 0 : uint16_t setCKEId = instr->v1.syncGSA.setCKEId;
955 0 : uint16_t setCKEMask = instr->v1.syncGSA.setCKEMask;
956 0 : uint16_t waitCKEId = instr->v1.syncGSA.waitCKEId;
957 0 : uint16_t waitCKEMask = instr->v1.syncGSA.waitCKEMask;
958 :
959 : return Hccl::StringFormat(
960 : "Wait CKE[%u:%04x], Sync locGSAId[%u] To rmtGSAId[%u] Use Channel[%u], Set rmtCKE[%u:%04x], Set "
961 : "CKE[%u:%04x], clearType[%u]",
962 : waitCKEId, waitCKEMask, locGSAId, rmtGSAId, channelId, setRmtCKEId, setRmtCKEMask, setCKEId, setCKEMask,
963 0 : clearType);
964 : }
965 :
966 10 : static std::string ParseSyncXnInstr(const CcuInstr* instr)
967 : {
968 10 : uint16_t rmtXnId = instr->v1.syncXn.rmtXnId;
969 10 : uint16_t locXnId = instr->v1.syncXn.locXnId;
970 10 : uint16_t channelId = instr->v1.syncXn.channelId;
971 10 : uint16_t setRmtCKEId = instr->v1.syncXn.setRmtCKEId;
972 10 : uint16_t setRmtCKEMask = instr->v1.syncXn.setRmtCKEMask;
973 10 : uint16_t clearType = instr->v1.syncXn.clearType;
974 10 : uint16_t setCKEId = instr->v1.syncXn.setCKEId;
975 10 : uint16_t setCKEMask = instr->v1.syncXn.setCKEMask;
976 10 : uint16_t waitCKEId = instr->v1.syncXn.waitCKEId;
977 10 : uint16_t waitCKEMask = instr->v1.syncXn.waitCKEMask;
978 :
979 : return Hccl::StringFormat(
980 : "Wait CKE[%u:%04x], Sync locXnId[%u] To rmtXnId[%u] Use Channel[%u], Set rmtCKE[%u:%04x], Set "
981 : "CKE[%u:%04x], clearType[%u]",
982 : waitCKEId, waitCKEMask, locXnId, rmtXnId, channelId, setRmtCKEId, setRmtCKEMask, setCKEId, setCKEMask,
983 10 : clearType);
984 : }
985 :
986 5 : static std::string ParseMSList(const CcuInstr* instr)
987 : {
988 : uint16_t msId[CCU_REDUCE_MAX_MS];
989 5 : uint16_t count = instr->v1.add.count;
990 45 : for (uint16_t index = 0; index < CCU_REDUCE_MAX_MS; index++) {
991 40 : msId[index] = instr->v1.add.msId[index];
992 : }
993 :
994 : // CCU指令中指定count数为实际参与运算的MS数减2，因此当count +
995 : // 2大于CCU_REDUCE_MAX_MS时，说明MS列表中的MS数量超过了CCU指令的最大支持数量，此时无法正确解析MS列表，直接返回"MS[]"
996 5 : if (count + 2 > CCU_REDUCE_MAX_MS) {
997 2 : return "MS[]";
998 : }
999 :
1000 4 : std::string res = "MS[";
1001 12 : for (uint16_t i = 0; i < count + 2; i++) { // 循环范围 0~count + 2
1002 8 : if (i == count + 1) {
1003 4 : res += std::to_string(msId[i] / 0x8000) + ":" + std::to_string(msId[i] % 0x8000) + "]";
1004 : } else {
1005 4 : res += std::to_string(msId[i] / 0x8000) + ":" + std::to_string(msId[i] % 0x8000) + ", ";
1006 : }
1007 : }
1008 4 : return res;
1009 4 : }
1010 :
1011 5 : static std::string ParseAddInstr(const CcuInstr* instr)
1012 : {
1013 5 : uint16_t count = instr->v1.add.count;
1014 5 : uint16_t castEn = instr->v1.add.castEn;
1015 5 : uint16_t dataType = instr->v1.add.dataType;
1016 5 : uint16_t clearType = instr->v1.add.clearType;
1017 5 : uint16_t setCKEId = instr->v1.add.setCKEId;
1018 5 : uint16_t setCKEMask = instr->v1.add.setCKEMask;
1019 5 : uint16_t waitCKEId = instr->v1.add.waitCKEId;
1020 5 : uint16_t waitCKEMask = instr->v1.add.waitCKEMask;
1021 :
1022 : return Hccl::StringFormat(
1023 : "Wait CKE[%u:%04x], Add %s with Count[%u], DataType[%u] and CastEn[%u], Set CKE[%u:%04x], clearType[%u]",
1024 5 : waitCKEId, waitCKEMask, ParseMSList(instr).c_str(), count, dataType, castEn, setCKEId, setCKEMask,
1025 10 : clearType);
1026 : }
1027 :
1028 0 : static std::string ParseMaxInstr(const CcuInstr* instr)
1029 : {
1030 0 : uint16_t count = instr->v1.max.count;
1031 0 : uint16_t dataType = instr->v1.max.dataType;
1032 0 : uint16_t clearType = instr->v1.max.clearType;
1033 0 : uint16_t setCKEId = instr->v1.max.setCKEId;
1034 0 : uint16_t setCKEMask = instr->v1.max.setCKEMask;
1035 0 : uint16_t waitCKEId = instr->v1.max.waitCKEId;
1036 0 : uint16_t waitCKEMask = instr->v1.max.waitCKEMask;
1037 :
1038 : return Hccl::StringFormat(
1039 : "Wait CKE[%u:%04x], Max %s with Count[%u], DataType[%u], Set CKE[%u:%04x], clearType[%u]", waitCKEId,
1040 0 : waitCKEMask, ParseMSList(instr).c_str(), count, dataType, setCKEId, setCKEMask, clearType);
1041 : }
1042 :
1043 0 : static std::string ParseMinInstr(const CcuInstr* instr)
1044 : {
1045 0 : uint16_t count = instr->v1.min.count;
1046 0 : uint16_t dataType = instr->v1.min.dataType;
1047 0 : uint16_t clearType = instr->v1.min.clearType;
1048 0 : uint16_t setCKEId = instr->v1.min.setCKEId;
1049 0 : uint16_t setCKEMask = instr->v1.min.setCKEMask;
1050 0 : uint16_t waitCKEId = instr->v1.min.waitCKEId;
1051 0 : uint16_t waitCKEMask = instr->v1.min.waitCKEMask;
1052 :
1053 : return Hccl::StringFormat(
1054 : "Wait CKE[%u:%04x], Min %s with Count[%u], DataType[%u], Set CKE[%u:%04x], clearType[%u]", waitCKEId,
1055 0 : waitCKEMask, ParseMSList(instr).c_str(), count, dataType, setCKEId, setCKEMask, clearType);
1056 : }
1057 :
1058 : using ParseInstrFunc = std::string (*)(const CcuInstr*);
1059 :
1060 : static std::unordered_map<uint16_t, ParseInstrFunc> g_parseInstrSqeMap = {
1061 : {InstrHeader(LOAD_TYPE, LOADSQEARGSTOGSA_CODE).header, &ParseLoadSqeArgsToGSAInstr},
1062 : {InstrHeader(LOAD_TYPE, LOADSQEARGSTOXN_CODE).header, &ParseLoadSqeArgsToXnInstr},
1063 : {InstrHeader(LOAD_TYPE, LOADIMDTOGSA_CODE).header, &ParseLoadImdToGSAInstr},
1064 : {InstrHeader(LOAD_TYPE, LOADIMDTOXN_CODE).header, &ParseLoadImdToXnInstr},
1065 : {InstrHeader(LOAD_TYPE, LOADGSAXN_CODE).header, &ParseLoadGSAXnInstr},
1066 : {InstrHeader(LOAD_TYPE, LOADGSAGSA_CODE).header, &ParseLoadGSAGSAInstr},
1067 : {InstrHeader(LOAD_TYPE, LOADXX_CODE).header, &ParseLoadXXInstr},
1068 : {InstrHeader(CTRL_TYPE, LOOP_CODE).header, &ParseLoopInstr},
1069 : {InstrHeader(CTRL_TYPE, LOOPGROUP_CODE).header, &ParseLoopGroupInstr},
1070 : {InstrHeader(CTRL_TYPE, SETCKE_CODE).header, &ParseSetCKEInstr},
1071 : {InstrHeader(CTRL_TYPE, CLEARCKE_CODE).header, &ParseClearCKEInstr},
1072 : {InstrHeader(CTRL_TYPE, JMP_CODE).header, &ParseJumpInstr},
1073 : {InstrHeader(TRANS_TYPE, TRANSLOCMEMTOLOCMS_CODE).header, &ParseTransLocMemToLocMSInstr},
1074 : {InstrHeader(TRANS_TYPE, TRANSRMTMEMTOLOCMS_CODE).header, &ParseTransRmtMemToLocMSInstr},
1075 : {InstrHeader(TRANS_TYPE, TRANSLOCMSTOLOCMEM_CODE).header, &ParseTransLocMSToLocMemInstr},
1076 : {InstrHeader(TRANS_TYPE, TRANSLOCMSTORMTMEM_CODE).header, &ParseTransLocMSToRmtMemInstr},
1077 : {InstrHeader(TRANS_TYPE, TRANSRMTMSTOLOCMEM_CODE).header, &ParseTransRmtMSToLocMemInstr},
1078 : {InstrHeader(TRANS_TYPE, TRANSLOCMSTOLOCMS_CODE).header, &ParseTransLocMSToLocMSInstr},
1079 : {InstrHeader(TRANS_TYPE, TRANSRMTMSTOLOCMS_CODE).header, &ParseTransRmtMSToLocMSInstr},
1080 : {InstrHeader(TRANS_TYPE, TRANSLOCMSTORMTMS_CODE).header, &ParseTransLocMSToRmtMSInstr},
1081 : {InstrHeader(TRANS_TYPE, TRANSRMTMEMTOLOCMEM_CODE).header, &ParseTransRmtMemToLocMemInstr},
1082 : {InstrHeader(TRANS_TYPE, TRANSLOCMEMTORMTMEM_CODE).header, &ParseTransLocMemToRmtMemInstr},
1083 : {InstrHeader(TRANS_TYPE, TRANSLOCMEMTOLOCMEM_CODE).header, &ParseTransLocMemToLocMemInstr},
1084 : {InstrHeader(TRANS_TYPE, SYNCCKE_CODE).header, &ParseSyncCKEInstr},
1085 : {InstrHeader(TRANS_TYPE, SYNCGSA_CODE).header, &ParseSyncGSAInstr},
1086 : {InstrHeader(TRANS_TYPE, SYNCXN_CODE).header, &ParseSyncXnInstr},
1087 : {InstrHeader(REDUCE_TYPE, ADD_CODE).header, &ParseAddInstr},
1088 : {InstrHeader(REDUCE_TYPE, MAX_CODE).header, &ParseMaxInstr},
1089 : {InstrHeader(REDUCE_TYPE, MIN_CODE).header, &ParseMinInstr},
1090 : };
1091 :
1092 2378 : std::string ParseInstr(const CcuInstr* instr)
1093 : {
1094 2378 : if (g_parseInstrSqeMap.find(instr->header.header) == g_parseInstrSqeMap.end()) {
1095 1 : return Hccl::StringFormat("Unsupported instruction with header: 0x%04x", instr->header.header);
1096 : }
1097 2377 : return g_parseInstrSqeMap[instr->header.header](instr);
1098 : }
1099 :
1100 : }; // namespace CcuRep
1101 : }; // namespace hcomm
|
