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