Line data Source code
1 : /*
2 : * Copyright (c) Huawei Technologies Co., Ltd. 2025-2025. All rights reserved.
3 : * Description: ccu instruction implement file
4 : * Author: sunzhepeng
5 : * Create: 2025-06-07
6 : */
7 :
8 : #include "ccu_microcode_v1.h"
9 :
10 : #include <unordered_map>
11 :
12 : #include "log.h"
13 : #include <string_util.h>
14 :
15 : namespace {
16 : constexpr uint16_t LOAD_TYPE = 0x0;
17 :
18 : constexpr uint16_t LOADSQEARGSTOX_CODE = 0x1;
19 : constexpr uint16_t LOADIMDTOX_CODE = 0x2;
20 : constexpr uint16_t LOADX_CODE = 0x6;
21 : constexpr uint16_t STOREX_CODE = 0x7;
22 : constexpr uint16_t CLEARX_CODE = 0x8;
23 : constexpr uint16_t NOP_CODE = 0x9;
24 : constexpr uint16_t LOAD_CODE = 0xA;
25 : constexpr uint16_t STORE_CODE = 0xB;
26 : constexpr uint16_t ADD_CODE = 0xD;
27 : constexpr uint16_t SUB_CODE = 0xE;
28 : constexpr uint16_t MUL_CODE = 0xF;
29 : constexpr uint16_t AND_CODE = 0x10;
30 : constexpr uint16_t OR_CODE = 0x11;
31 : constexpr uint16_t NOT_CODE = 0x12;
32 : constexpr uint16_t XOR_CODE = 0x13;
33 : constexpr uint16_t SHL_CODE = 0x14;
34 : constexpr uint16_t SHR_CODE = 0x15;
35 : constexpr uint16_t POPCNT_CODE = 0x16;
36 :
37 : constexpr uint16_t CTRL_TYPE = 0x1;
38 :
39 : constexpr uint16_t LOOP_CODE = 0x0;
40 : constexpr uint16_t LOOPGROUP_CODE = 0x1;
41 : constexpr uint16_t SETCKBIT_CODE = 0x2;
42 : constexpr uint16_t CLEARCKBIT_CODE = 0x4;
43 : constexpr uint16_t JMP_CODE = 0x5;
44 : constexpr uint16_t WAIT_CODE = 0x7;
45 : constexpr uint16_t FENCE_CODE = 0x8;
46 :
47 : constexpr uint16_t TRANS_TYPE = 0x2;
48 :
49 : constexpr uint16_t TRANSLOCMEMTOLOCMS_CODE = 0x0;
50 : constexpr uint16_t TRANSLOCMSTOLOCMEM_CODE = 0x2;
51 : constexpr uint16_t TRANSLOCMSTOLOCMS_CODE = 0x5;
52 : constexpr uint16_t TRANSLOCMEMTOLOCMEM_CODE = 0x6;
53 : constexpr uint16_t TRANSMEM_CODE = 0x10;
54 : constexpr uint16_t SYNCWTX_CODE = 0xD;
55 : constexpr uint16_t SYNCATX_CODE = 0xE;
56 :
57 : constexpr uint16_t REDUCE_TYPE = 0x3;
58 :
59 : constexpr uint16_t REDUCE_ADD_CODE = 0x0;
60 : constexpr uint16_t REDUCE_MAX_CODE = 0x1;
61 : constexpr uint16_t REDUCE_MIN_CODE = 0x2;
62 :
63 : constexpr uint16_t JMP_TARGET_PC_IF_BRANCH = 5; // Jmp跳转到IF分支的目标PC
64 : constexpr uint16_t JMP_TARGET_PC_NOP_BRANCH = 3; // Jmp跳转到Nop的目标PC
65 : constexpr uint16_t JMP_COND_TYPE_IF = 2; // Jmp条件类型: IF分支
66 : constexpr uint16_t JMP_COND_TYPE_UNCOND = 6; // Jmp条件类型: 无条件
67 : } // namespace
68 :
69 : namespace hcomm {
70 : namespace CcuRep {
71 : namespace CcuV2 {
72 : // *XnId = *sqeArgsId
73 15 : void LoadSqeArgsToX(CcuInstr* instr, uint16_t xnId, uint16_t sqeArgsId, uint16_t setCKEId, uint16_t setCKEMask)
74 : {
75 15 : instr->header = InstrHeader(LOAD_TYPE, LOADSQEARGSTOX_CODE);
76 15 : instr->v2.loadSqeArgsToX.xnId = xnId;
77 15 : instr->v2.loadSqeArgsToX.sqeArgsId = sqeArgsId;
78 15 : instr->v2.loadSqeArgsToX.setCKEId = setCKEId;
79 15 : instr->v2.loadSqeArgsToX.setCKEMask = setCKEMask;
80 15 : }
81 :
82 : // *XnId = immediate
83 266 : void LoadImdToXn(CcuInstr* instr, uint16_t xnId, uint64_t immediate, uint16_t setCKEId, uint16_t setCKEMask)
84 : {
85 266 : instr->header = InstrHeader(LOAD_TYPE, LOADIMDTOX_CODE);
86 266 : instr->v2.loadImdToX.xnId = xnId;
87 266 : instr->v2.loadImdToX.immediate = immediate;
88 266 : instr->v2.loadImdToX.setCKEId = setCKEId;
89 266 : instr->v2.loadImdToX.setCKEMask = setCKEMask;
90 266 : }
91 :
92 0 : void ClearX(
93 : CcuInstr* instr, uint16_t xnId, uint16_t xmId, uint16_t xnIdMode, uint16_t xmIdMode, uint16_t setCKEId,
94 : uint16_t setCKEMask)
95 : {
96 0 : instr->header = InstrHeader(LOAD_TYPE, CLEARX_CODE);
97 0 : instr->v2.clearX.xnId = xnId & 0x7FFF;
98 0 : instr->v2.clearX.xnIdMode = xnIdMode & 0x1;
99 0 : instr->v2.clearX.xmId = xmId & 0x7FFF;
100 0 : instr->v2.clearX.xmIdMode = xmIdMode & 0x1;
101 0 : instr->v2.clearX.setCKEId = setCKEId;
102 0 : instr->v2.clearX.setCKEMask = setCKEMask;
103 0 : }
104 :
105 181 : void Nop(CcuInstr* instr) { instr->header = InstrHeader(LOAD_TYPE, NOP_CODE); }
106 :
107 : inline void
108 178 : Operator(CcuInstr* instr, uint16_t xdId, uint16_t xnId, uint16_t xmId, uint16_t setCKEId, uint16_t setCKEMask)
109 : {
110 178 : instr->v2.operate.xdId = xdId;
111 178 : instr->v2.operate.xnId = xnId;
112 178 : instr->v2.operate.xmId = xmId;
113 178 : instr->v2.operate.setCKEId = setCKEId;
114 178 : instr->v2.operate.setCKEMask = setCKEMask;
115 178 : }
116 :
117 59 : void Assign(CcuInstr* instr, uint16_t result, uint16_t operand, uint16_t setCKEId, uint16_t setCKEMask)
118 : {
119 59 : AddI(instr, result, operand, 0, setCKEId, setCKEMask);
120 59 : }
121 :
122 131 : void AssignI(CcuInstr* instr, uint16_t result, uint64_t operand, uint16_t setCKEId, uint16_t setCKEMask)
123 : {
124 131 : LoadImdToXn(instr, result, operand, setCKEId, setCKEMask);
125 131 : }
126 :
127 : void
128 57 : Add(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
129 : uint16_t setCKEMask)
130 : {
131 57 : instr->header = InstrHeader(LOAD_TYPE, ADD_CODE);
132 57 : instr->v2.operate.parMode = 1;
133 57 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
134 57 : }
135 :
136 : void
137 64 : AddI(CcuInstr* instr, uint16_t result, uint16_t operand, uint16_t imm, uint16_t setCKEId, uint16_t setCKEMask)
138 : {
139 64 : instr->header = InstrHeader(LOAD_TYPE, ADD_CODE);
140 64 : instr->v2.operate.parMode = 0;
141 64 : Operator(instr, result, operand, imm, setCKEId, setCKEMask);
142 64 : }
143 :
144 : void
145 5 : Sub(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
146 : uint16_t setCKEMask)
147 : {
148 5 : instr->header = InstrHeader(LOAD_TYPE, SUB_CODE);
149 :
150 : // 设置指令模式，Par_Mode = 1’b1时，*Xd = *Xn – *Xm
151 5 : instr->v2.operate.parMode = 1;
152 5 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
153 5 : }
154 :
155 : void
156 3 : SubI(CcuInstr* instr, uint16_t result, uint16_t operand, uint16_t imm, uint16_t setCKEId, uint16_t setCKEMask)
157 : {
158 3 : instr->header = InstrHeader(LOAD_TYPE, SUB_CODE);
159 :
160 : // 设置指令模式，Par_Mode = 1’b0时，*Xd = *Xn - {48’b0，Immedata[15:0]}
161 3 : instr->v2.operate.parMode = 0;
162 3 : Operator(instr, result, operand, imm, setCKEId, setCKEMask);
163 3 : }
164 :
165 : void
166 5 : Mul(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
167 : uint16_t setCKEMask)
168 : {
169 5 : instr->header = InstrHeader(LOAD_TYPE, MUL_CODE);
170 5 : instr->v2.operate.parMode = 1;
171 5 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
172 5 : }
173 :
174 : void
175 3 : MulI(CcuInstr* instr, uint16_t result, uint16_t operand, uint16_t imm, uint16_t setCKEId, uint16_t setCKEMask)
176 : {
177 3 : instr->header = InstrHeader(LOAD_TYPE, MUL_CODE);
178 3 : instr->v2.operate.parMode = 0;
179 3 : Operator(instr, result, operand, imm, setCKEId, setCKEMask);
180 3 : }
181 :
182 : void
183 13 : And(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
184 : uint16_t setCKEMask)
185 : {
186 13 : instr->header = InstrHeader(LOAD_TYPE, AND_CODE);
187 13 : instr->v2.operate.parMode = 1;
188 13 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
189 13 : }
190 :
191 : void
192 4 : Or(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
193 : uint16_t setCKEMask)
194 : {
195 4 : instr->header = InstrHeader(LOAD_TYPE, OR_CODE);
196 4 : instr->v2.operate.parMode = 1;
197 4 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
198 4 : }
199 :
200 : void
201 2 : Xor(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
202 : uint16_t setCKEMask)
203 : {
204 2 : instr->header = InstrHeader(LOAD_TYPE, XOR_CODE);
205 2 : instr->v2.operate.parMode = 1;
206 2 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
207 2 : }
208 :
209 1 : void Not(CcuInstr* instr, uint16_t result, uint16_t operand, uint16_t setCKEId, uint16_t setCKEMask)
210 : {
211 1 : instr->header = InstrHeader(LOAD_TYPE, NOT_CODE);
212 1 : instr->v2.operate.parMode = 0;
213 1 : Operator(instr, result, operand, 0, setCKEId, setCKEMask);
214 1 : }
215 :
216 : void
217 8 : SLL(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
218 : uint16_t setCKEMask)
219 : {
220 8 : instr->header = InstrHeader(LOAD_TYPE, SHL_CODE);
221 8 : instr->v2.operate.shiftType = 0;
222 8 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
223 8 : }
224 :
225 : void
226 13 : SRL(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
227 : uint16_t setCKEMask)
228 : {
229 13 : instr->header = InstrHeader(LOAD_TYPE, SHR_CODE);
230 13 : instr->v2.operate.shiftType = 0;
231 13 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
232 13 : }
233 :
234 : void
235 0 : SLA(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
236 : uint16_t setCKEMask)
237 : {
238 0 : instr->header = InstrHeader(LOAD_TYPE, SHL_CODE);
239 0 : instr->v2.operate.shiftType = 1;
240 0 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
241 0 : }
242 :
243 : void
244 0 : SRA(CcuInstr* instr, uint16_t result, uint16_t operand1, uint16_t operand2, uint16_t setCKEId,
245 : uint16_t setCKEMask)
246 : {
247 0 : instr->header = InstrHeader(LOAD_TYPE, SHR_CODE);
248 0 : instr->v2.operate.shiftType = 1;
249 0 : Operator(instr, result, operand1, operand2, setCKEId, setCKEMask);
250 0 : }
251 :
252 : // LoadChannel、LoadInstruction暂不实现
253 :
254 0 : void LoadFromMem(
255 : CcuInstr* instr, uint16_t dst, uint16_t src, uint16_t srcToken, uint16_t len,
256 : const CacheConfig& cacheConfig, uint16_t setCKEId, uint16_t setCKEMask)
257 : {
258 0 : instr->header = InstrHeader(LOAD_TYPE, LOAD_CODE);
259 0 : instr->v2.load.xdId = dst;
260 0 : instr->v2.load.xsId = src;
261 0 : instr->v2.load.xstId = srcToken;
262 0 : instr->v2.load.xlId = len;
263 :
264 0 : instr->v2.load.allocHint = cacheConfig.allocHint & 0x3;
265 0 : instr->v2.load.victimHint = cacheConfig.victimHint & 0x3;
266 :
267 0 : instr->v2.load.setCKEId = setCKEId;
268 0 : instr->v2.load.setCKEMask = setCKEMask;
269 0 : }
270 :
271 0 : void LoadXFromMem(
272 : CcuInstr* instr, uint16_t dst, uint16_t src, uint16_t srcToken, uint16_t len,
273 : const CacheConfig& cacheConfig, uint16_t setCKEId, uint16_t setCKEMask)
274 : {
275 0 : if (instr == nullptr) {
276 0 : HCCL_ERROR("[CcuV2::LoadXFromMem] instr is nullptr!");
277 0 : return;
278 : }
279 0 : LoadFromMem(instr, dst, src, srcToken, len, cacheConfig, setCKEId, setCKEMask);
280 0 : instr->v2.load.dstType = 0x0;
281 : }
282 :
283 : // HSCB Store暂不实现
284 :
285 0 : void StoreXToMem(
286 : CcuInstr* instr, uint16_t dst, uint16_t dstToken, uint16_t src, uint16_t len,
287 : const CacheConfig& cacheConfig, uint16_t setCKEId, uint16_t setCKEMask)
288 : {
289 0 : instr->header = InstrHeader(LOAD_TYPE, STORE_CODE);
290 0 : instr->v2.store.xdId = dst;
291 0 : instr->v2.store.xdtId = dstToken;
292 0 : instr->v2.store.xsId = src;
293 0 : instr->v2.store.xlId = len;
294 0 : instr->v2.store.xhId = 0x0;
295 :
296 0 : instr->v2.store.srcType = 0x0;
297 0 : instr->v2.store.storeType = 0b0;
298 0 : instr->v2.store.hscbBroadCastDstType = 0x0;
299 :
300 0 : instr->v2.store.allocHint = cacheConfig.allocHint & 0x3;
301 0 : instr->v2.store.victimHint = cacheConfig.victimHint & 0x3;
302 :
303 0 : instr->v2.store.setCKEId = setCKEId;
304 0 : instr->v2.store.setCKEMask = setCKEMask;
305 0 : }
306 :
307 : // HSCB Broadcast 暂不实现
308 0 : void HSCBStoreXToMem(
309 : CcuInstr* instr, uint16_t dst, uint16_t src, uint16_t len, const CacheConfig& cacheConfig,
310 : uint16_t setCKEId, uint16_t setCKEMask)
311 : {
312 0 : instr->header = InstrHeader(LOAD_TYPE, STORE_CODE);
313 0 : instr->v2.store.xdId = dst;
314 0 : instr->v2.store.xdtId = 0x0;
315 0 : instr->v2.store.xsId = src;
316 0 : instr->v2.store.xlId = len;
317 0 : instr->v2.store.xhId = 0x0;
318 :
319 0 : instr->v2.store.srcType = 0x0;
320 0 : instr->v2.store.storeType = 0b1;
321 0 : instr->v2.store.hscbType = 0b0;
322 0 : instr->v2.store.hscbBroadCastDstType = 0x0;
323 :
324 0 : instr->v2.store.allocHint = cacheConfig.allocHint & 0x3;
325 0 : instr->v2.store.victimHint = cacheConfig.victimHint & 0x3;
326 :
327 0 : instr->v2.store.setCKEId = setCKEId;
328 0 : instr->v2.store.setCKEMask = setCKEMask;
329 0 : }
330 :
331 : // startInstrId ~ endInstrId之间的指令构成loop
332 : // Xm寄存器中的内容：LoopCtxId[52:45], Offset[44:13], IterNum[12:0]
333 : // IterNum[12:0] loop执行IterNum次 loop每次执行, 地址偏移为Offset loop在第LoopCtxId个LoopEngine上执行
334 19 : void Loop(
335 : CcuInstr* instr, uint16_t startInstrId, uint16_t endInstrId, uint16_t iterNum, uint16_t offset,
336 : uint16_t contextId)
337 : {
338 19 : instr->header = InstrHeader(CTRL_TYPE, LOOP_CODE);
339 19 : instr->v2.loop.startInstrId = startInstrId;
340 19 : instr->v2.loop.endInstrId = endInstrId;
341 19 : instr->v2.loop.xmId = iterNum;
342 19 : instr->v2.loop.xnId = offset;
343 19 : instr->v2.loop.xpId = contextId;
344 19 : instr->v2.loop.mode = 0;
345 19 : instr->v2.loop.wishCKEBit = 0;
346 19 : }
347 :
348 : // startLoopInstrId为LoopGroup所包含的Loop的起始地址
349 : // Xn寄存器中的内容：ExtendNum[22:16], RepeatLoopIndex[15:9], LoopNum[8:0]
350 : // Xm寄存器中的内容：gsaOffset[52:21], MSOffset[20:10], ckeOffset[9:0]
351 : // xnOffset[52:21], xnOffset[31:0]
352 : // 从startLoopInstrId开始，共LoopNum个Loop，并且从RepeatLoopIndex个开始，展开ExtendNum次
353 : // 每个展开的Loop，使用的MSId偏移为msOffset，使用的CKEId偏移为ckeOffset，使用的地址偏移为gsaOffset,
354 : // 使用的XnId偏移为xnOffset
355 9 : void LoopGroup(
356 : CcuInstr* instr, uint16_t startLoopInstrId, uint16_t loopGroupConfig, uint16_t resOffset, uint16_t xnOffset)
357 : {
358 9 : instr->header = InstrHeader(CTRL_TYPE, LOOPGROUP_CODE);
359 9 : instr->v2.loopGroup.startLoopInstrId = startLoopInstrId;
360 9 : instr->v2.loopGroup.xnId = loopGroupConfig;
361 9 : instr->v2.loopGroup.xmId = resOffset;
362 9 : instr->v2.loopGroup.xpId = xnOffset;
363 9 : }
364 :
365 : // 后续函数中, 均需要wait到<waitCKEId, waitCKEMask>后, 再执行相关操作, 执行完之后再set<setCKEId, setCKEMask>
366 : // clearType = 1时, wait到之后需要对<waitCKEId, waitCKEMask>清零, 否则不清零
367 :
368 4 : void SetCKE(
369 : CcuInstr* instr, uint16_t setCKEId, uint16_t setCKEMask, uint16_t waitCKEId, uint16_t waitCKEMask,
370 : uint16_t clearType)
371 : {
372 4 : instr->header = InstrHeader(CTRL_TYPE, SETCKBIT_CODE);
373 4 : instr->v2.setCKE.clearType = clearType & 0x1;
374 4 : instr->v2.setCKE.setCKEId = setCKEId;
375 4 : instr->v2.setCKE.setCKEMask = setCKEMask;
376 4 : instr->v2.setCKE.waitCKEId = waitCKEId;
377 4 : instr->v2.setCKE.waitCKEMask = waitCKEMask;
378 4 : instr->v2.setCKE.userData = 0;
379 4 : }
380 :
381 6 : void ClearCKE(
382 : CcuInstr* instr, uint16_t clearCKEId, uint16_t clearMask, uint16_t waitCKEId, uint16_t waitCKEMask,
383 : uint16_t clearType)
384 : {
385 6 : instr->header = InstrHeader(CTRL_TYPE, CLEARCKBIT_CODE);
386 6 : instr->v2.clearCKE.clearType = clearType & 0x1;
387 6 : instr->v2.clearCKE.clearCKEId = clearCKEId;
388 6 : instr->v2.clearCKE.clearMask = clearMask;
389 6 : instr->v2.clearCKE.waitCKEId = waitCKEId;
390 6 : instr->v2.clearCKE.waitCKEMask = waitCKEMask;
391 6 : }
392 :
393 40 : void Jump(
394 : CcuInstr* instr, uint16_t relTarInstrXnId, uint16_t conditionXnId, uint16_t expectedXnId,
395 : uint16_t conditionType)
396 : {
397 40 : instr->header = InstrHeader(CTRL_TYPE, JMP_CODE);
398 40 : instr->v2.jmp.expectedXnId = expectedXnId;
399 40 : instr->v2.jmp.conditionXnId = conditionXnId;
400 40 : instr->v2.jmp.relTarInstrXnId = relTarInstrXnId;
401 40 : instr->v2.jmp.conditionType = conditionType & 0xF;
402 40 : }
403 :
404 0 : void Wait(CcuInstr* instr, uint16_t conditionXnId, uint16_t expectedXnId, uint16_t conditionType)
405 : {
406 0 : instr->header = InstrHeader(CTRL_TYPE, WAIT_CODE);
407 0 : instr->v2.wait.expectedXnId = expectedXnId;
408 0 : instr->v2.wait.conditionXnId = conditionXnId;
409 0 : instr->v2.wait.conditionType = conditionType & 0xF;
410 0 : }
411 :
412 0 : void Fence(CcuInstr* instr) { instr->header = InstrHeader(CTRL_TYPE, FENCE_CODE); }
413 :
414 : // 本端Memory传输到本端MS
415 4 : void TransLocMemToLocMS(
416 : CcuInstr* instr, uint16_t ms, uint16_t src, uint16_t srcToken, uint16_t len, uint16_t offset,
417 : uint16_t setCKEId, uint16_t setCKEMask, const CacheConfig& cacheConfig)
418 : {
419 4 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMEMTOLOCMS_CODE);
420 4 : instr->v2.transLocMemToLocMS.msId = ms;
421 4 : instr->v2.transLocMemToLocMS.xsId = src;
422 4 : instr->v2.transLocMemToLocMS.xstId = srcToken;
423 4 : instr->v2.transLocMemToLocMS.xlId = len;
424 4 : instr->v2.transLocMemToLocMS.xoId = offset;
425 4 : instr->v2.transLocMemToLocMS.allocHint = cacheConfig.allocHint & 0x3;
426 4 : instr->v2.transLocMemToLocMS.victimHint = cacheConfig.victimHint & 0x3;
427 4 : instr->v2.transLocMemToLocMS.setCKEId = setCKEId;
428 4 : instr->v2.transLocMemToLocMS.setCKEMask = setCKEMask;
429 4 : }
430 :
431 : // 本端MS传输到本端Memory
432 2 : void TransLocMSToLocMem(
433 : CcuInstr* instr, uint16_t dst, uint16_t dstToken, uint16_t ms, uint16_t len, uint16_t offset,
434 : uint16_t setCKEId, uint16_t setCKEMask, const CacheConfig& cacheConfig)
435 : {
436 2 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMSTOLOCMEM_CODE);
437 2 : instr->v2.transLocMSToLocMem.xdId = dst;
438 2 : instr->v2.transLocMSToLocMem.xdtId = dstToken;
439 2 : instr->v2.transLocMSToLocMem.msId = ms;
440 2 : instr->v2.transLocMSToLocMem.xlId = len;
441 2 : instr->v2.transLocMSToLocMem.xoId = offset;
442 2 : instr->v2.transLocMSToLocMem.allocHint = cacheConfig.allocHint & 0x3;
443 2 : instr->v2.transLocMSToLocMem.victimHint = cacheConfig.victimHint & 0x3;
444 2 : instr->v2.transLocMSToLocMem.setCKEId = setCKEId;
445 2 : instr->v2.transLocMSToLocMem.setCKEMask = setCKEMask;
446 2 : }
447 :
448 0 : void TransLocMemToLocMem(
449 : CcuInstr* instr, uint16_t dst, uint16_t dstToken, uint16_t src, uint16_t srcToken, uint16_t len,
450 : uint16_t usedMSId, uint16_t usedMSNum, uint16_t setCKEId, uint16_t setCKEMask,
451 : const CacheConfig& srcCacheConfig, const CacheConfig& dstcacheConfig)
452 : {
453 0 : instr->header = InstrHeader(TRANS_TYPE, TRANSLOCMEMTOLOCMEM_CODE);
454 0 : instr->v2.transLocMemToLocMem.xdId = dst;
455 0 : instr->v2.transLocMemToLocMem.xdtId = dstToken;
456 0 : instr->v2.transLocMemToLocMem.xsId = src;
457 0 : instr->v2.transLocMemToLocMem.xstId = srcToken;
458 0 : instr->v2.transLocMemToLocMem.xlId = len;
459 0 : instr->v2.transLocMemToLocMem.usedMSId = usedMSId;
460 0 : instr->v2.transLocMemToLocMem.msNum = usedMSNum;
461 :
462 0 : instr->v2.transLocMemToLocMem.srcAllocHint = srcCacheConfig.allocHint & 0x3;
463 0 : instr->v2.transLocMemToLocMem.srcVictimHint = srcCacheConfig.victimHint & 0x3;
464 0 : instr->v2.transLocMemToLocMem.dstAllocHint = dstcacheConfig.allocHint & 0x3;
465 0 : instr->v2.transLocMemToLocMem.dstVictimHint = dstcacheConfig.victimHint & 0x3;
466 :
467 0 : instr->v2.transLocMemToLocMem.setCKEId = setCKEId;
468 0 : instr->v2.transLocMemToLocMem.setCKEMask = setCKEMask;
469 0 : }
470 :
471 1 : void TransMem(
472 : CcuInstr* instr, uint16_t dst, uint16_t dstToken, uint16_t src, uint16_t srcToken, uint16_t len,
473 : uint16_t channel, const TransMemNotifyInfo& notify, const TransMemReduceInfo& reduce,
474 : const TransMemConfig& config, uint16_t setCKEId, uint16_t setCKEMask)
475 : {
476 1 : instr->header = InstrHeader(TRANS_TYPE, TRANSMEM_CODE);
477 1 : instr->v2.transMem.xdId = dst;
478 1 : instr->v2.transMem.xdtId = dstToken;
479 1 : instr->v2.transMem.xsId = src;
480 1 : instr->v2.transMem.xstId = srcToken;
481 1 : instr->v2.transMem.xlId = len;
482 1 : instr->v2.transMem.xcId = channel;
483 1 : instr->v2.transMem.xnId = notify.xnId;
484 1 : instr->v2.transMem.xntId = notify.xntId;
485 1 : instr->v2.transMem.value = notify.value;
486 1 : instr->v2.transMem.udfType = reduce.udfType & 0xFF;
487 1 : instr->v2.transMem.reduceDataType = reduce.reduceDataType & 0xF;
488 1 : instr->v2.transMem.reduceOpCode = reduce.reduceOpCode & 0xF;
489 1 : instr->v2.transMem.dmaOpCode = config.dmaOpCode & 0xFF;
490 :
491 1 : instr->v2.transMem.order = config.order & 0x7;
492 1 : instr->v2.transMem.fence = config.fence & 0x1;
493 1 : instr->v2.transMem.cqe = config.cqe & 0x1;
494 1 : instr->v2.transMem.nf = config.nf & 0x1;
495 1 : instr->v2.transMem.udfEnable = config.udfEnable & 0x1;
496 1 : instr->v2.transMem.splitMode = config.splitMode & 0x1;
497 1 : instr->v2.transMem.se = config.se & 0x1;
498 1 : instr->v2.transMem.rmtJettyType = config.rmtJettyType & 0x3;
499 :
500 1 : instr->v2.transMem.src_mode = config.src_mode & 0x1;
501 1 : instr->v2.transMem.dst_mode = config.dst_mode & 0x1;
502 1 : instr->v2.transMem.msIdMode = config.msIdMode & 0x1;
503 :
504 1 : instr->v2.transMem.targetHint = 0x0;
505 :
506 1 : instr->v2.transMem.setCKEId = setCKEId;
507 1 : instr->v2.transMem.setCKEMask = setCKEMask;
508 1 : }
509 :
510 : // 将本端Xn的值写入远端8B地址
511 4 : inline void SyncWtX(
512 : CcuInstr* instr, uint16_t dst, uint16_t dstToken, uint16_t xn, uint16_t channelId, uint16_t setCKEId,
513 : uint16_t setCKEMask)
514 : {
515 4 : instr->header = InstrHeader(TRANS_TYPE, SYNCWTX_CODE);
516 4 : instr->v2.syncWtX.xdId = dst;
517 4 : instr->v2.syncWtX.xdtId = dstToken;
518 4 : instr->v2.syncWtX.xsId = xn;
519 4 : instr->v2.syncWtX.xcId = channelId;
520 :
521 4 : instr->v2.syncWtX.setCKEId = setCKEId;
522 4 : instr->v2.syncWtX.setCKEMask = setCKEMask;
523 4 : }
524 :
525 : // 将本端Xn的值写入远端8B地址并置位远端CKE
526 3 : void SyncWtX(
527 : CcuInstr* instr, uint16_t dst, uint16_t dstToken, uint16_t xn, uint16_t channelId,
528 : const TransMemNotifyInfo& notify, uint16_t setCKEId, uint16_t setCKEMask)
529 : {
530 3 : SyncWtX(instr, dst, dstToken, xn, channelId, setCKEId, setCKEMask);
531 3 : instr->v2.syncWtX.xnId = notify.xnId;
532 3 : instr->v2.syncWtX.xntId = notify.xntId;
533 3 : instr->v2.syncWtX.value = notify.value;
534 :
535 3 : instr->v2.syncWtX.notifyValid = 1;
536 3 : instr->v2.syncWtX.parMode = 1;
537 3 : }
538 :
539 : // 置位远端CKE
540 1 : void SyncWtX(
541 : CcuInstr* instr, const TransMemNotifyInfo& notify, uint16_t channelId, uint16_t setCKEId,
542 : uint16_t setCKEMask)
543 : {
544 1 : SyncWtX(instr, notify.xnId, notify.xntId, notify.value, channelId, setCKEId, setCKEMask);
545 :
546 1 : instr->v2.syncWtX.notifyValid = 0;
547 1 : instr->v2.syncWtX.parMode = 0;
548 1 : }
549 :
550 : // 将本端Xn的值以atomic store add的方式写入远端8B地址
551 0 : void SyncAtX(
552 : CcuInstr* instr, uint16_t dstAddr, uint16_t dstToken, uint16_t srcId, uint16_t channelId, uint16_t setCKEId,
553 : uint16_t setCKEMask)
554 : {
555 0 : instr->header = InstrHeader(TRANS_TYPE, SYNCATX_CODE);
556 0 : instr->v2.syncAtX.xdId = dstAddr;
557 0 : instr->v2.syncAtX.xdtId = dstToken;
558 0 : instr->v2.syncAtX.xsId = srcId;
559 0 : instr->v2.syncAtX.xcId = channelId;
560 :
561 0 : instr->v2.syncAtX.parMode = 1;
562 :
563 0 : instr->v2.syncAtX.setCKEId = setCKEId;
564 0 : instr->v2.syncAtX.setCKEMask = setCKEMask;
565 0 : }
566 :
567 : // MSA~MSH Reduce到 MSA
568 2 : inline void Reduce(
569 : CcuInstr* instr, const uint16_t* ms, uint16_t count, uint16_t castEn, uint16_t dataType, uint16_t setCKEId,
570 : uint16_t setCKEMask, uint16_t XnIdLength)
571 : {
572 : // 由调用者保证传入的count >= 2(reduce的数据源)
573 2 : if (count < CCU_REDUCE_MIN_MS) {
574 0 : HCCL_ERROR("[CcuV2::Reduce] count %u < min %u", count, CCU_REDUCE_MIN_MS);
575 0 : return;
576 : }
577 2 : count -= 2; // CCU指令中指定count数为实际参与运算的MS数减2
578 :
579 18 : for (uint16_t index = 0; index < CCU_REDUCE_MAX_MS; index++) {
580 16 : instr->v2.reduce.msId[index] = ms[index];
581 : }
582 2 : instr->v2.reduce.XnIdLength = XnIdLength;
583 2 : instr->v2.reduce.count = count & 0x7;
584 2 : instr->v2.reduce.castEn = castEn & 0x3;
585 2 : instr->v2.reduce.dataType = dataType & 0x1f;
586 2 : instr->v2.reduce.setCKEId = setCKEId;
587 2 : instr->v2.reduce.setCKEMask = setCKEMask;
588 : }
589 :
590 2 : void ReduceAdd(
591 : CcuInstr* instr, const uint16_t* ms, uint16_t count, uint16_t castEn, uint16_t dataType, uint16_t setCKEId,
592 : uint16_t setCKEMask, uint16_t XnIdLength)
593 : {
594 2 : if (instr == nullptr) {
595 0 : HCCL_ERROR("[CcuV2::ReduceAdd] instr is nullptr!");
596 0 : return;
597 : }
598 2 : instr->header = InstrHeader(REDUCE_TYPE, REDUCE_ADD_CODE);
599 2 : Reduce(instr, ms, count, castEn, dataType, setCKEId, setCKEMask, XnIdLength);
600 : }
601 :
602 0 : void ReduceMax(
603 : CcuInstr* instr, const uint16_t* ms, uint16_t count, uint16_t dataType, uint16_t setCKEId,
604 : uint16_t setCKEMask, uint16_t XnIdLength)
605 : {
606 0 : if (instr == nullptr) {
607 0 : HCCL_ERROR("[CcuV2::ReduceMax] instr is nullptr!");
608 0 : return;
609 : }
610 0 : instr->header = InstrHeader(REDUCE_TYPE, REDUCE_MAX_CODE);
611 0 : Reduce(instr, ms, count, 0, dataType, setCKEId, setCKEMask, XnIdLength);
612 : }
613 :
614 0 : void ReduceMin(
615 : CcuInstr* instr, const uint16_t* ms, uint16_t count, uint16_t dataType, uint16_t setCKEId,
616 : uint16_t setCKEMask, uint16_t xnIdLength)
617 : {
618 0 : if (instr == nullptr) {
619 0 : HCCL_ERROR("[CcuV2::ReduceMin] instr is nullptr!");
620 0 : return;
621 : }
622 0 : instr->header = InstrHeader(REDUCE_TYPE, REDUCE_MIN_CODE);
623 0 : Reduce(instr, ms, count, 0, dataType, setCKEId, setCKEMask, xnIdLength);
624 : }
625 :
626 30 : std::string ParseLoadSqeArgsToX(const CcuInstr* instr)
627 : {
628 30 : uint16_t xnId = instr->v2.loadSqeArgsToX.xnId;
629 30 : uint16_t sqeArgsId = instr->v2.loadSqeArgsToX.sqeArgsId;
630 30 : uint16_t setCKEId = instr->v2.loadSqeArgsToX.setCKEId;
631 30 : uint16_t setCKEMask = instr->v2.loadSqeArgsToX.setCKEMask;
632 :
633 : // 使用 StringFormat 格式化字符串
634 : return Hccl::StringFormat(
635 30 : "Load SqeArg[%u] to Xn[%u], Set CKE[%u:%04x]", sqeArgsId, xnId, setCKEId, setCKEMask);
636 : }
637 :
638 499 : std::string ParseLoadImdToXn(const CcuInstr* instr)
639 : {
640 499 : uint16_t xnId = instr->v2.loadImdToX.xnId;
641 499 : uint64_t immediate = instr->v2.loadImdToX.immediate;
642 499 : uint16_t setCKEId = instr->v2.loadImdToX.setCKEId;
643 499 : uint16_t setCKEMask = instr->v2.loadImdToX.setCKEMask;
644 :
645 : // 使用 StringFormat 格式化字符串
646 : return Hccl::StringFormat(
647 499 : "Load immediate[%llu] to Xn[%u], Set CKE[%u:%04x]", immediate, xnId, setCKEId, setCKEMask);
648 : }
649 :
650 0 : std::string ParseClearX(const CcuInstr* instr)
651 : {
652 0 : uint16_t xnId = instr->v2.clearX.xnId;
653 0 : uint16_t xmId = instr->v2.clearX.xmId;
654 0 : uint16_t setCKEId = instr->v2.clearX.setCKEId;
655 0 : uint16_t setCKEMask = instr->v2.clearX.setCKEMask;
656 :
657 : // 使用 StringFormat 格式化字符串
658 : return Hccl::StringFormat(
659 0 : "CleanX: xnId[%u] to xmId[%u], Set CKE[%u:%04x]", xnId, xmId, setCKEId, setCKEMask);
660 : }
661 :
662 212 : std::string ParseNop(const CcuInstr* instr)
663 : {
664 : (void)instr;
665 212 : return Hccl::StringFormat("Nop");
666 : }
667 :
668 232 : std::string ParseAdd(const CcuInstr* instr)
669 : {
670 232 : uint16_t xdId = instr->v2.operate.xdId;
671 232 : uint16_t xnId = instr->v2.operate.xnId;
672 232 : uint16_t xmId = instr->v2.operate.xmId;
673 232 : uint16_t setCKEId = instr->v2.operate.setCKEId;
674 232 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
675 232 : uint16_t parMode = instr->v2.operate.parMode;
676 :
677 : // 使用 StringFormat 格式化字符串
678 232 : if (instr->v2.operate.parMode == 0) {
679 : return Hccl::StringFormat(
680 : "AddI:xdId[%u] = xnId[%u] + immediata[%u], Set CKE[%u:%04x], parMode[%u]", xdId, xnId, xmId,
681 122 : setCKEId, setCKEMask, parMode);
682 : } else {
683 : return Hccl::StringFormat(
684 : "Add:xdId[%u] = xnId[%u] + xmId[%u], Set CKE[%u:%04x], parMode[%u]", xdId, xnId, xmId, setCKEId,
685 110 : setCKEMask, parMode);
686 : }
687 : }
688 :
689 8 : std::string ParseSub(const CcuInstr* instr)
690 : {
691 8 : uint16_t xdId = instr->v2.operate.xdId;
692 8 : uint16_t xnId = instr->v2.operate.xnId;
693 8 : uint16_t xmId = instr->v2.operate.xmId;
694 8 : uint16_t setCKEId = instr->v2.operate.setCKEId;
695 8 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
696 8 : uint16_t parMode = instr->v2.operate.parMode;
697 :
698 : // 使用 StringFormat 格式化字符串
699 8 : if (instr->v2.operate.parMode == 0) {
700 : return Hccl::StringFormat(
701 : "SubI:xdId[%u] = xnId[%u] - immediata[%u], Set CKE[%u:%04x], parMode[%u]", xdId, xnId, xmId,
702 4 : setCKEId, setCKEMask, parMode);
703 : } else {
704 : return Hccl::StringFormat(
705 : "Sub:xdId[%u] = xnId[%u] - xmId[%u], Set CKE[%u:%04x], parMode[%u]", xdId, xnId, xmId, setCKEId,
706 4 : setCKEMask, parMode);
707 : }
708 : }
709 :
710 8 : std::string ParseMul(const CcuInstr* instr)
711 : {
712 8 : uint16_t xdId = instr->v2.operate.xdId;
713 8 : uint16_t xnId = instr->v2.operate.xnId;
714 8 : uint16_t xmId = instr->v2.operate.xmId;
715 8 : uint16_t setCKEId = instr->v2.operate.setCKEId;
716 8 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
717 8 : uint16_t parMode = instr->v2.operate.parMode;
718 :
719 : // 使用 StringFormat 格式化字符串
720 8 : if (instr->v2.operate.parMode == 0) {
721 : return Hccl::StringFormat(
722 : "MulI:xdId[%u] = xnId[%u] * immediata[%u], Set CKE[%u:%04x], parMode[%u]", xdId, xnId, xmId,
723 4 : setCKEId, setCKEMask, parMode);
724 : } else {
725 : return Hccl::StringFormat(
726 : "Mul:xdId[%u] = xnId[%u] * xmId[%u], Set CKE[%u:%04x], parMode[%u]", xdId, xnId, xmId, setCKEId,
727 4 : setCKEMask, parMode);
728 : }
729 : }
730 :
731 26 : std::string ParseAnd(const CcuInstr* instr)
732 : {
733 26 : uint16_t xdId = instr->v2.operate.xdId;
734 26 : uint16_t xnId = instr->v2.operate.xnId;
735 26 : uint16_t xmId = instr->v2.operate.xmId;
736 26 : uint16_t setCKEId = instr->v2.operate.setCKEId;
737 26 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
738 :
739 : // 使用 StringFormat 格式化字符串
740 : return Hccl::StringFormat(
741 26 : "And:xdId[%u] = xnId[%u] & xmId[%u], Set CKE[%u:%04x]", xdId, xnId, xmId, setCKEId, setCKEMask);
742 : }
743 :
744 8 : std::string ParseOr(const CcuInstr* instr)
745 : {
746 8 : uint16_t xdId = instr->v2.operate.xdId;
747 8 : uint16_t xnId = instr->v2.operate.xnId;
748 8 : uint16_t xmId = instr->v2.operate.xmId;
749 8 : uint16_t setCKEId = instr->v2.operate.setCKEId;
750 8 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
751 :
752 : // 使用 StringFormat 格式化字符串
753 : return Hccl::StringFormat(
754 8 : "Or:xdId[%u] = xnId[%u] | xmId[%u], Set CKE[%u:%04x]", xdId, xnId, xmId, setCKEId, setCKEMask);
755 : }
756 :
757 4 : std::string ParseXor(const CcuInstr* instr)
758 : {
759 4 : uint16_t xdId = instr->v2.operate.xdId;
760 4 : uint16_t xnId = instr->v2.operate.xnId;
761 4 : uint16_t xmId = instr->v2.operate.xmId;
762 4 : uint16_t setCKEId = instr->v2.operate.setCKEId;
763 4 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
764 :
765 : // 使用 StringFormat 格式化字符串
766 : return Hccl::StringFormat(
767 4 : "Xor:xdId[%u] = xnId[%u] ^ xmId[%u], Set CKE[%u:%04x]", xdId, xnId, xmId, setCKEId, setCKEMask);
768 : }
769 :
770 2 : std::string ParseNot(const CcuInstr* instr)
771 : {
772 2 : uint16_t xdId = instr->v2.operate.xdId;
773 2 : uint16_t xnId = instr->v2.operate.xnId;
774 2 : uint16_t setCKEId = instr->v2.operate.setCKEId;
775 2 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
776 :
777 : // 使用 StringFormat 格式化字符串
778 2 : return Hccl::StringFormat("Not:xdId[%u] = ~xnId[%u], Set CKE[%u:%04x]", xdId, xnId, setCKEId, setCKEMask);
779 : }
780 :
781 8 : std::string ParseShl(const CcuInstr* instr)
782 : {
783 8 : uint16_t xdId = instr->v2.operate.xdId;
784 8 : uint16_t xnId = instr->v2.operate.xnId;
785 8 : uint16_t xmId = instr->v2.operate.xmId;
786 8 : uint16_t shiftType = instr->v2.operate.shiftType;
787 8 : uint16_t setCKEId = instr->v2.operate.setCKEId;
788 8 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
789 :
790 : // 使用 StringFormat 格式化字符串
791 8 : if (shiftType == 0) {
792 : return Hccl::StringFormat(
793 : "logic left shift:xdId[%u] = xnId[%u] << xmId[%u], Set CKE[%u:%04x]", xdId, xnId, xmId, setCKEId,
794 8 : setCKEMask);
795 : } else {
796 : return Hccl::StringFormat(
797 : "arithmetic left shift:xdId[%u] = xnId[%u] << xmId[%u], Set CKE[%u:%04x]", xdId, xnId, xmId,
798 0 : setCKEId, setCKEMask);
799 : }
800 : }
801 :
802 18 : std::string ParseShr(const CcuInstr* instr)
803 : {
804 18 : uint16_t xdId = instr->v2.operate.xdId;
805 18 : uint16_t xnId = instr->v2.operate.xnId;
806 18 : uint16_t xmId = instr->v2.operate.xmId;
807 18 : uint16_t shiftType = instr->v2.operate.shiftType;
808 18 : uint16_t setCKEId = instr->v2.operate.setCKEId;
809 18 : uint16_t setCKEMask = instr->v2.operate.setCKEMask;
810 :
811 : // 使用 StringFormat 格式化字符串
812 18 : if (shiftType == 0) {
813 : return Hccl::StringFormat(
814 : "logic right shift:xdId[%u] = xnId[%u] >> xmId[%u], Set CKE[%u:%04x]", xdId, xnId, xmId, setCKEId,
815 18 : setCKEMask);
816 : } else {
817 : return Hccl::StringFormat(
818 : "arithmetic right shift:xdId[%u] = xnId[%u] >> xmId[%u], Set CKE[%u:%04x]", xdId, xnId, xmId,
819 0 : setCKEId, setCKEMask);
820 : }
821 : }
822 :
823 0 : std::string ParseLoadFromMem(const CcuInstr* instr)
824 : {
825 0 : uint16_t xdId = instr->v2.load.xdId;
826 0 : uint16_t xsId = instr->v2.load.xsId;
827 0 : uint16_t xstId = instr->v2.load.xstId;
828 0 : uint16_t xlId = instr->v2.load.xlId;
829 0 : uint16_t allocHint = instr->v2.load.allocHint;
830 0 : uint16_t victimHint = instr->v2.load.victimHint;
831 0 : uint16_t setCKEId = instr->v2.load.setCKEId;
832 0 : uint16_t setCKEMask = instr->v2.load.setCKEMask;
833 0 : uint16_t dstType = instr->v2.load.dstType;
834 :
835 : return Hccl::StringFormat(
836 : "LoadFromMem: xdId[%u] xsId[%u] xstId[%u] xlId[%u], allocHint[%u], victimHint[%u], setCKEId[%u], "
837 : "setCKEMask[%u] dstType[%u]",
838 0 : xdId, xsId, xstId, xlId, allocHint, victimHint, setCKEId, setCKEMask, dstType);
839 : }
840 :
841 0 : std::string ParseStoreXToMem(const CcuInstr* instr)
842 : {
843 0 : uint16_t xdId = instr->v2.store.xdId;
844 0 : uint16_t xdtId = instr->v2.store.xdtId;
845 0 : uint16_t xsId = instr->v2.store.xsId;
846 0 : uint16_t xlId = instr->v2.store.xlId;
847 0 : uint16_t xhId = instr->v2.store.xhId;
848 0 : uint16_t srcType = instr->v2.store.srcType;
849 0 : uint16_t allocHint = instr->v2.store.allocHint;
850 0 : uint16_t victimHint = instr->v2.store.victimHint;
851 0 : uint16_t storeType = instr->v2.store.storeType;
852 0 : uint16_t hscbType = instr->v2.store.hscbType;
853 0 : uint16_t hscbBroadCastDstType = instr->v2.store.hscbBroadCastDstType;
854 0 : uint16_t setCKEId = instr->v2.store.setCKEId;
855 0 : uint16_t setCKEMask = instr->v2.store.setCKEMask;
856 :
857 : // 使用 StringFormat 格式化字符串
858 : return Hccl::StringFormat(
859 : "StoreXToMem: xdId[%u] xdtId[%u], xsId[%u], xlId[%u], xhId[%u], srcType[%u], allocHint[%u], "
860 : "victimHint[%u], storeType[%u], hscbType[%u], hscbBroadCastDstType[%u], set CKE[%u:%04x]",
861 : xdId, xdtId, xsId, xlId, xhId, srcType, allocHint, victimHint, storeType, hscbType,
862 0 : hscbBroadCastDstType, setCKEId, setCKEMask);
863 : }
864 :
865 38 : std::string ParseLoop(const CcuInstr* instr)
866 : {
867 38 : uint16_t startInstrId = instr->v2.loop.startInstrId;
868 38 : uint16_t endInstrId = instr->v2.loop.endInstrId;
869 38 : uint16_t xmId = instr->v2.loop.xmId;
870 38 : uint16_t xnId = instr->v2.loop.xnId;
871 38 : uint16_t xpId = instr->v2.loop.xpId;
872 38 : uint16_t wishCKEBit = instr->v2.loop.wishCKEBit;
873 38 : uint16_t mode = instr->v2.loop.mode;
874 :
875 : // 使用 StringFormat 格式化字符串
876 : return Hccl::StringFormat(
877 : "Loop From startInstrId[%u] to endInstrId[%u] with iterNumXn[%u], OffsetXn[%u], ContextIdXn[%u],"
878 : "wishCKEBit[%u], mode[%u]",
879 38 : startInstrId, endInstrId, xmId, xnId, xpId, wishCKEBit, mode);
880 : }
881 :
882 18 : std::string ParseLoopGroup(const CcuInstr* instr)
883 : {
884 18 : uint16_t startLoopInstrId = instr->v2.loopGroup.startLoopInstrId;
885 18 : uint16_t xnId = instr->v2.loopGroup.xnId;
886 18 : uint16_t xmId = instr->v2.loopGroup.xmId;
887 18 : uint16_t xpId = instr->v2.loopGroup.xpId;
888 :
889 : // 使用 StringFormat 格式化字符串
890 : return Hccl::StringFormat(
891 : "LoopGroup From startLoopInstrId[%u] with loopGroupXn[%u], resOffsetXn[%u], xnOffset[%u]",
892 18 : startLoopInstrId, xnId, xmId, xpId);
893 : }
894 :
895 80 : std::string ParseJump(const CcuInstr* instr)
896 : {
897 80 : uint16_t relTarInstrXnId = instr->v2.jmp.relTarInstrXnId;
898 80 : uint16_t conditionXnId = instr->v2.jmp.conditionXnId;
899 80 : uint16_t expectedXnId = instr->v2.jmp.expectedXnId;
900 80 : uint16_t conditionType = instr->v2.jmp.conditionType;
901 :
902 : // 使用 StringFormat 格式化字符串
903 : return Hccl::StringFormat(
904 : "When conditionXn[%u] condition with[%u] expectedXn[%u], Jump To RelInstrIdXn[%u]", conditionXnId,
905 80 : conditionType, expectedXnId, relTarInstrXnId);
906 : }
907 :
908 0 : std::string ParseWait(const CcuInstr* instr)
909 : {
910 0 : uint16_t conditionXnId = instr->v2.wait.conditionXnId;
911 0 : uint16_t expectedXnId = instr->v2.wait.expectedXnId;
912 0 : uint16_t conditionType = instr->v2.wait.conditionType;
913 :
914 : // 使用 StringFormat 格式化字符串
915 : return Hccl::StringFormat(
916 0 : "Wait conditionXn[%u] condition with[%u] expectedXn[%u]", conditionXnId, conditionType, expectedXnId);
917 : }
918 :
919 0 : std::string ParseFence(const CcuInstr* instr)
920 : {
921 : (void)instr;
922 0 : return Hccl::StringFormat("Fence");
923 : }
924 :
925 23 : std::string ParseSetCKE(const CcuInstr* instr)
926 : {
927 23 : uint16_t setCKEId = instr->v2.setCKE.setCKEId;
928 23 : uint16_t setCKEMask = instr->v2.setCKE.setCKEMask;
929 23 : uint16_t waitCKEId = instr->v2.setCKE.waitCKEId;
930 23 : uint16_t waitCKEMask = instr->v2.setCKE.waitCKEMask;
931 23 : uint16_t clearType = instr->v2.setCKE.clearType;
932 23 : uint64_t userData = instr->v2.setCKE.userData;
933 :
934 : // 使用 StringFormat 格式化字符串
935 : return Hccl::StringFormat(
936 : "Wait CKE[%u:%04x], Set CKE[%u:%04x], clearType[%u], userData[%llu]", waitCKEId, waitCKEMask, setCKEId,
937 23 : setCKEMask, clearType, userData);
938 : }
939 :
940 12 : std::string ParseClearCKE(const CcuInstr* instr)
941 : {
942 12 : uint16_t clearCKEId = instr->v2.clearCKE.clearCKEId;
943 12 : uint16_t clearMask = instr->v2.clearCKE.clearMask;
944 12 : uint16_t waitCKEId = instr->v2.clearCKE.waitCKEId;
945 12 : uint16_t waitCKEMask = instr->v2.clearCKE.waitCKEMask;
946 12 : uint16_t clearType = instr->v2.clearCKE.clearType & 0x1;
947 :
948 : // 使用 StringFormat 格式化字符串
949 : return Hccl::StringFormat(
950 : "Wait CKE[%u:%04x], Clear CKE[%u:%04x], clearType[%u]", waitCKEId, waitCKEMask, clearCKEId, clearMask,
951 12 : clearType);
952 : }
953 :
954 8 : std::string ParseTransLocMemToLocMS(const CcuInstr* instr)
955 : {
956 8 : uint16_t ms = instr->v2.transLocMemToLocMS.msId;
957 8 : uint16_t src = instr->v2.transLocMemToLocMS.xsId;
958 8 : uint16_t srcToken = instr->v2.transLocMemToLocMS.xstId;
959 8 : uint16_t len = instr->v2.transLocMemToLocMS.xlId;
960 8 : uint16_t offset = instr->v2.transLocMemToLocMS.xoId;
961 8 : uint16_t allocHint = instr->v2.transLocMemToLocMS.allocHint;
962 8 : uint16_t victimHint = instr->v2.transLocMemToLocMS.victimHint;
963 8 : uint16_t setCKEId = instr->v2.transLocMemToLocMS.setCKEId;
964 8 : uint16_t setCKEMask = instr->v2.transLocMemToLocMS.setCKEMask;
965 :
966 : // 使用 StringFormat 格式化字符串
967 : return Hccl::StringFormat(
968 : "Trans LocMem[%u:%u] To LocMS[%u] With LengthXn[%u], Offset[%u], Set CKE[%u:%04x], "
969 : "allocHint[%u], victimHint[%u]",
970 8 : src, srcToken, ms, len, offset, setCKEId, setCKEMask, allocHint, victimHint);
971 : }
972 :
973 4 : std::string ParseTransLocMSToLocMem(const CcuInstr* instr)
974 : {
975 4 : uint16_t dst = instr->v2.transLocMSToLocMem.xdId;
976 4 : uint16_t dstToken = instr->v2.transLocMSToLocMem.xdtId;
977 4 : uint16_t ms = instr->v2.transLocMSToLocMem.msId;
978 4 : uint16_t len = instr->v2.transLocMSToLocMem.xlId;
979 4 : uint16_t offset = instr->v2.transLocMSToLocMem.xoId;
980 4 : uint16_t allocHint = instr->v2.transLocMSToLocMem.allocHint;
981 4 : uint16_t victimHint = instr->v2.transLocMSToLocMem.victimHint;
982 4 : uint16_t setCKEId = instr->v2.transLocMSToLocMem.setCKEId;
983 4 : uint16_t setCKEMask = instr->v2.transLocMSToLocMem.setCKEMask;
984 :
985 : // 使用 StringFormat 格式化字符串
986 : return Hccl::StringFormat(
987 : "Trans LocMS[%u] To LocMem[%u:%u] With LengthXn[%u], Offset[%u], Set CKE[%u:%04x], "
988 : "allocHint[%u], victimHint[%u]",
989 4 : ms, dst, dstToken, len, offset, setCKEId, setCKEMask, allocHint, victimHint);
990 : }
991 :
992 0 : std::string ParseTransLocMemToLocMem(const CcuInstr* instr)
993 : {
994 0 : uint16_t dst = instr->v2.transLocMemToLocMem.xdId;
995 0 : uint16_t dstToken = instr->v2.transLocMemToLocMem.xdtId;
996 0 : uint16_t src = instr->v2.transLocMemToLocMem.xsId;
997 0 : uint16_t srcToken = instr->v2.transLocMemToLocMem.xstId;
998 0 : uint16_t len = instr->v2.transLocMemToLocMem.xlId;
999 0 : uint16_t usedMSId = instr->v2.transLocMemToLocMem.usedMSId;
1000 0 : uint16_t msNum = instr->v2.transLocMemToLocMem.msNum;
1001 :
1002 0 : uint16_t srcAllocHint = instr->v2.transLocMemToLocMem.srcAllocHint;
1003 0 : uint16_t srcVictimHint = instr->v2.transLocMemToLocMem.srcVictimHint;
1004 0 : uint16_t dstAllocHint = instr->v2.transLocMemToLocMem.dstAllocHint;
1005 0 : uint16_t dstVictimHint = instr->v2.transLocMemToLocMem.dstVictimHint;
1006 :
1007 0 : uint16_t setCKEId = instr->v2.transLocMemToLocMem.setCKEId;
1008 0 : uint16_t setCKEMask = instr->v2.transLocMemToLocMem.setCKEMask;
1009 :
1010 : // 使用 StringFormat 格式化字符串
1011 : return Hccl::StringFormat(
1012 : "Trans LocMem[%u:%u] To LocMem[%u:%u] With Length[%u], Set CKE[%u:%04x], usedMSId[%u], msNum[%u],"
1013 : "srcAllocHint[%u], srcVictimHint[%u], dstAllocHint[%u], dstVictimHint[%u]",
1014 : src, srcToken, dst, dstToken, len, setCKEId, setCKEMask, usedMSId, msNum, srcAllocHint, srcVictimHint,
1015 0 : dstAllocHint, dstVictimHint);
1016 : }
1017 :
1018 2 : std::string ParseTransMem(const CcuInstr* instr)
1019 : {
1020 2 : uint16_t dst = instr->v2.transMem.xdId;
1021 2 : uint16_t dstToken = instr->v2.transMem.xdtId;
1022 2 : uint16_t src = instr->v2.transMem.xsId;
1023 2 : uint16_t srcToken = instr->v2.transMem.xstId;
1024 2 : uint16_t len = instr->v2.transMem.xlId;
1025 2 : uint16_t channel = instr->v2.transMem.xcId;
1026 :
1027 2 : uint16_t notifyXnId = instr->v2.transMem.xnId;
1028 2 : uint16_t notifyXntId = instr->v2.transMem.xntId;
1029 2 : uint16_t notifyValue = instr->v2.transMem.value;
1030 :
1031 2 : uint16_t reduceUdfType = instr->v2.transMem.udfType;
1032 2 : uint16_t reduceDataType = instr->v2.transMem.reduceDataType;
1033 2 : uint16_t reduceOpCode = instr->v2.transMem.reduceOpCode;
1034 :
1035 2 : uint16_t configOpCode = instr->v2.transMem.dmaOpCode;
1036 2 : uint16_t configOrder = instr->v2.transMem.order;
1037 2 : uint16_t configFence = instr->v2.transMem.fence;
1038 2 : uint16_t configCqe = instr->v2.transMem.cqe;
1039 2 : uint16_t configNf = instr->v2.transMem.nf;
1040 2 : uint16_t configUdfEnable = instr->v2.transMem.udfEnable;
1041 2 : uint16_t configSplitMode = instr->v2.transMem.splitMode;
1042 2 : uint16_t configSe = instr->v2.transMem.se;
1043 2 : uint16_t configRmtJettyType = instr->v2.transMem.rmtJettyType;
1044 2 : uint16_t configTargetHint = instr->v2.transMem.targetHint;
1045 :
1046 2 : uint16_t setCKEId = instr->v2.transMem.setCKEId;
1047 2 : uint16_t setCKEMask = instr->v2.transMem.setCKEMask;
1048 :
1049 2 : uint16_t srcMode = instr->v2.transMem.src_mode;
1050 2 : uint16_t dstMode = instr->v2.transMem.dst_mode;
1051 2 : uint16_t msIdMode = instr->v2.transMem.msIdMode;
1052 :
1053 : // 使用 StringFormat 格式化字符串
1054 : return Hccl::StringFormat(
1055 : "Trans Mem[%u:%u] To Mem[%u:%u] With Len[%u] Use Channel[%u] Set CKE[%u:%04x], notifyXnId[%u], "
1056 : "notifyXntId[%u], notifyValue[%u], reduceUdfType[%u], reduceDataType[%u], reduceOpCode[%u], "
1057 : "configOpCode[%u], Order[%u], Fence[%u], Cqe[%u], Nf[%u], UdfEnable[%u], SplitMode[%u], Se[%u], "
1058 : "RmtJettyType[%u], configTargetHint[%u], srcMode[%u], dstMode[%u], msIdMode[%u]",
1059 : src, srcToken, dst, dstToken, len, channel, setCKEId, setCKEMask, notifyXnId, notifyXntId, notifyValue,
1060 : reduceUdfType, reduceDataType, reduceOpCode, configOpCode, configOrder, configFence, configCqe,
1061 : configNf, configUdfEnable, configSplitMode, configSe, configRmtJettyType, configTargetHint, srcMode,
1062 2 : dstMode, msIdMode);
1063 : }
1064 :
1065 8 : std::string ParseSyncWtX(const CcuInstr* instr)
1066 : {
1067 8 : uint16_t dst = instr->v2.syncWtX.xdId;
1068 8 : uint16_t dstToken = instr->v2.syncWtX.xdtId;
1069 8 : uint16_t xn = instr->v2.syncWtX.xsId;
1070 8 : uint16_t channelId = instr->v2.syncWtX.xcId;
1071 :
1072 8 : uint16_t setCKEId = instr->v2.syncWtX.setCKEId;
1073 8 : uint16_t setCKEMask = instr->v2.syncWtX.setCKEMask;
1074 :
1075 : // 检查是否包含通知信息
1076 8 : bool hasNotify = (instr->v2.syncWtX.notifyValid != 0);
1077 8 : uint16_t parMode = instr->v2.syncWtX.parMode;
1078 8 : uint16_t notifyXnId = hasNotify ? instr->v2.syncWtX.xnId : 0;
1079 8 : uint16_t notifyXntId = hasNotify ? instr->v2.syncWtX.xntId : 0;
1080 8 : uint16_t notifyValue = hasNotify ? instr->v2.syncWtX.value : 0;
1081 :
1082 : // 使用 StringFormat 格式化字符串
1083 8 : if (hasNotify) {
1084 : return Hccl::StringFormat(
1085 : "Sync Xn[%u] To Mem[%u:%u] Use ChannelXn[%u], with notify[%u:%u:%04x], and Set CKE[%u:%04x], "
1086 : "parMode[%u]",
1087 6 : xn, dst, dstToken, channelId, notifyXnId, notifyXntId, notifyValue, setCKEId, setCKEMask, parMode);
1088 : } else {
1089 : return Hccl::StringFormat(
1090 : "Sync Xn[%u] To Mem[%u:%u] Use ChannelXn[%u], and Set CKE[%u:%04x], parMode[%u]", xn, dst, dstToken,
1091 2 : channelId, setCKEId, setCKEMask, parMode);
1092 : }
1093 : }
1094 :
1095 0 : std::string ParseSyncAtX(const CcuInstr* instr)
1096 : {
1097 0 : uint16_t xdId = instr->v2.syncAtX.xdId;
1098 0 : uint16_t xdtId = instr->v2.syncAtX.xdtId;
1099 0 : uint16_t xsId = instr->v2.syncAtX.xsId;
1100 0 : uint16_t xcId = instr->v2.syncAtX.xcId;
1101 0 : uint16_t parMode = instr->v2.syncAtX.parMode;
1102 0 : uint16_t setCKEId = instr->v2.syncAtX.setCKEId;
1103 0 : uint16_t setCKEMask = instr->v2.syncAtX.setCKEMask;
1104 :
1105 : return Hccl::StringFormat(
1106 : "Atomic Sync xsId[%u] To Mem[%u:%u] Use ChannelXn[%u], parMode[%u], setCKEId[%u:%04x]", xsId, xdId,
1107 0 : xdtId, xcId, parMode, setCKEId, setCKEMask);
1108 : }
1109 :
1110 4 : std::string ParseMSListV2(const uint16_t* msId, uint16_t msNum)
1111 : {
1112 4 : std::string res = "MS[";
1113 12 : for (uint16_t i = 0; i < msNum + 2 && i < CCU_REDUCE_MAX_MS; i++) { // 循环范围 0 ~ count+ 2，防止越界
1114 8 : if (i == msNum + 1) {
1115 4 : res += std::to_string(msId[i] / 0x8000) + ":" + std::to_string(msId[i] % 0x8000) + "]";
1116 : } else {
1117 4 : res += std::to_string(msId[i] / 0x8000) + ":" + std::to_string(msId[i] % 0x8000) + ", ";
1118 : }
1119 : }
1120 :
1121 4 : return res;
1122 0 : }
1123 :
1124 4 : std::string ParseReduce(const CcuInstr* instr)
1125 : {
1126 4 : uint16_t reduceType = instr->header.code;
1127 4 : uint16_t count = instr->v2.reduce.count;
1128 4 : uint16_t castEn = instr->v2.reduce.castEn;
1129 4 : uint16_t dataType = instr->v2.reduce.dataType;
1130 4 : uint16_t setCKEId = instr->v2.reduce.setCKEId;
1131 4 : uint16_t setCKEMask = instr->v2.reduce.setCKEMask;
1132 :
1133 : return Hccl::StringFormat(
1134 : "Reduce %s, count[%u], reduceType[%u], castEn[%u] and dataType[%u], Set CKE[%u:%04x]",
1135 4 : ParseMSListV2(instr->v2.reduce.msId, count).c_str(), count, reduceType, castEn, dataType, setCKEId,
1136 8 : setCKEMask);
1137 : }
1138 :
1139 : using ParseInstrFunc = std::string (*)(const CcuInstr*);
1140 : static const std::unordered_map<uint16_t, ParseInstrFunc> g_parseInstrSqeMapV2
1141 : = {{InstrHeader(LOAD_TYPE, LOADSQEARGSTOX_CODE).header, &ParseLoadSqeArgsToX},
1142 : {InstrHeader(LOAD_TYPE, LOADIMDTOX_CODE).header, &ParseLoadImdToXn},
1143 : {InstrHeader(LOAD_TYPE, CLEARX_CODE).header, &ParseClearX},
1144 : {InstrHeader(LOAD_TYPE, NOP_CODE).header, &ParseNop},
1145 : {InstrHeader(LOAD_TYPE, ADD_CODE).header, &ParseAdd},
1146 : {InstrHeader(LOAD_TYPE, SUB_CODE).header, &ParseSub},
1147 : {InstrHeader(LOAD_TYPE, MUL_CODE).header, &ParseMul},
1148 : {InstrHeader(LOAD_TYPE, AND_CODE).header, &ParseAnd},
1149 : {InstrHeader(LOAD_TYPE, OR_CODE).header, &ParseOr},
1150 : {InstrHeader(LOAD_TYPE, XOR_CODE).header, &ParseXor},
1151 : {InstrHeader(LOAD_TYPE, NOT_CODE).header, &ParseNot},
1152 : {InstrHeader(LOAD_TYPE, SHL_CODE).header, &ParseShl},
1153 : {InstrHeader(LOAD_TYPE, SHR_CODE).header, &ParseShr},
1154 : {InstrHeader(LOAD_TYPE, LOAD_CODE).header, &ParseLoadFromMem},
1155 : {InstrHeader(LOAD_TYPE, STORE_CODE).header, &ParseStoreXToMem},
1156 : {InstrHeader(CTRL_TYPE, LOOP_CODE).header, &ParseLoop},
1157 : {InstrHeader(CTRL_TYPE, LOOPGROUP_CODE).header, &ParseLoopGroup},
1158 : {InstrHeader(CTRL_TYPE, JMP_CODE).header, &ParseJump},
1159 : {InstrHeader(CTRL_TYPE, WAIT_CODE).header, &ParseWait},
1160 : {InstrHeader(CTRL_TYPE, FENCE_CODE).header, &ParseFence},
1161 : {InstrHeader(CTRL_TYPE, SETCKBIT_CODE).header, &ParseSetCKE},
1162 : {InstrHeader(CTRL_TYPE, CLEARCKBIT_CODE).header, &ParseClearCKE},
1163 : {InstrHeader(TRANS_TYPE, TRANSLOCMEMTOLOCMS_CODE).header, &ParseTransLocMemToLocMS},
1164 : {InstrHeader(TRANS_TYPE, TRANSLOCMSTOLOCMEM_CODE).header, &ParseTransLocMSToLocMem},
1165 : {InstrHeader(TRANS_TYPE, TRANSLOCMEMTOLOCMEM_CODE).header, &ParseTransLocMemToLocMem},
1166 : {InstrHeader(TRANS_TYPE, TRANSMEM_CODE).header, &ParseTransMem},
1167 : {InstrHeader(TRANS_TYPE, SYNCWTX_CODE).header, &ParseSyncWtX},
1168 : {InstrHeader(TRANS_TYPE, SYNCATX_CODE).header, &ParseSyncAtX},
1169 : {InstrHeader(REDUCE_TYPE, REDUCE_ADD_CODE).header, &ParseReduce},
1170 : {InstrHeader(REDUCE_TYPE, REDUCE_MAX_CODE).header, &ParseReduce},
1171 : {InstrHeader(REDUCE_TYPE, REDUCE_MIN_CODE).header, &ParseReduce}};
1172 :
1173 1252 : std::string ParseInstrV2(const CcuInstr* instr)
1174 : {
1175 1252 : if (instr == nullptr) {
1176 0 : HCCL_ERROR("ParseInstr input nullptr!");
1177 0 : return std::string();
1178 : }
1179 :
1180 1252 : auto it = g_parseInstrSqeMapV2.find(instr->header.header);
1181 1252 : if (it == g_parseInstrSqeMapV2.end()) {
1182 0 : HCCL_ERROR("Not support instr type %u code %u", instr->header.type, instr->header.code);
1183 0 : return std::string();
1184 : }
1185 :
1186 1252 : return it->second(instr);
1187 : }
1188 :
1189 0 : void RelJmp(CcuInstr* instr, uint16_t targetXnId, uint32_t jmpInstrId, uint16_t xn0, uint16_t xn1)
1190 : {
1191 0 : CcuV2::LoadImdToXn(instr++, xn0, jmpInstrId);
1192 0 : CcuV2::LoadImdToXn(instr++, xn1, JMP_TARGET_PC_IF_BRANCH);
1193 0 : CcuV2::Jump(instr++, xn1, targetXnId, xn0, JMP_COND_TYPE_IF);
1194 0 : CcuV2::LoadImdToXn(instr++, xn0, 0x10000 - jmpInstrId);
1195 0 : CcuV2::Add(instr++, targetXnId, targetXnId, xn0);
1196 0 : CcuV2::LoadImdToXn(instr++, xn1, JMP_TARGET_PC_NOP_BRANCH);
1197 0 : CcuV2::Jump(instr++, xn1, 0, 0, JMP_COND_TYPE_UNCOND);
1198 0 : CcuV2::Sub(instr++, targetXnId, targetXnId, xn0);
1199 0 : CcuV2::Nop(instr++);
1200 0 : }
1201 : }; // namespace CcuV2
1202 :
1203 : }; // namespace CcuRep
1204 : }; // namespace hcomm
|
