Debian Codegraph @

visa/iga/IGALibrary/Backend/Messages/E64/MessageDecoderE64.cpp

raw
1 /*========================== begin_copyright_notice ============================
2
3 Copyright (C) 2022 Intel Corporation
4
5 SPDX-License-Identifier: MIT
6
7 ============================= end_copyright_notice ===========================*/
8 #include "MessageDecoderE64.hpp"
9
10 #include <string_view>
11
12 #define LSC_LOOKUP_TABLE(FIELD, OFF, LEN, TBL) \
13 lookupFromTable(FIELD, OFF, LEN, TBL, sizeof(TBL) / sizeof(TBL[0]))
14
15 using namespace iga;
16
17 static const LscCacheValidValue LSC_CACHING_LD[]{
18 LscCacheValidValue{0x0, CacheOpt::DEFAULT, CacheOpt::DEFAULT, CacheOpt::DEFAULT,
19 ".df.df.df", "L1 state, L2 MOCS, L3 MOCS"},
20 LscCacheValidValue{0x2, CacheOpt::UNCACHED, CacheOpt::UNCACHED, CacheOpt::UNCACHED,
21 ".uc.uc.uc", "L1 uncached, L2 uncached, L3 uncached"},
22 LscCacheValidValue{0x3, CacheOpt::UNCACHED, CacheOpt::UNCACHED, CacheOpt::CACHED,
23 ".uc.uc.ca", "L1 uncached, L2 uncached, L3 cached"},
24 LscCacheValidValue{0x4, CacheOpt::UNCACHED, CacheOpt::CACHED, CacheOpt::UNCACHED,
25 ".uc.ca.uc", "L1 uncached, L2 cached, L3 uncached"},
26 LscCacheValidValue{0x4, CacheOpt::UNCACHED, CacheOpt::CACHED, CacheOpt::UNCACHED,
27 ".uc.ca.uc", "L1 uncached, L2 cached, L3 uncached"},
28 LscCacheValidValue{0x5, CacheOpt::UNCACHED, CacheOpt::CACHED, CacheOpt::CACHED,
29 ".uc.ca.ca", "L1 uncached, L2 cached, L3 cached"},
30 LscCacheValidValue{0x6, CacheOpt::CACHED, CacheOpt::UNCACHED, CacheOpt::UNCACHED,
31 ".ca.uc.uc", "L1 cached, L2 uncached, L3 uncached"},
32 LscCacheValidValue{0x7, CacheOpt::CACHED, CacheOpt::UNCACHED, CacheOpt::CACHED,
33 ".ca.uc.ca", "L1 cached, L2 uncached, L3 cached"},
34 LscCacheValidValue{0x8, CacheOpt::CACHED, CacheOpt::CACHED, CacheOpt::UNCACHED,
35 ".ca.ca.uc", "L1 cached, L2 cached, L3 uncached"},
36 LscCacheValidValue{0x9, CacheOpt::CACHED, CacheOpt::CACHED, CacheOpt::CACHED,
37 ".ca.ca.ca", "L1 cached, L2 cached, L3 cached"},
38 LscCacheValidValue{0xA, CacheOpt::STREAMING, CacheOpt::UNCACHED, CacheOpt::UNCACHED,
39 ".st.uc.uc", "L1 streaming, L2 uncached, L3 uncached"},
40 LscCacheValidValue{0xB, CacheOpt::STREAMING, CacheOpt::UNCACHED, CacheOpt::CACHED,
41 ".st.uc.ca", "L1 streaming, L2 uncached, L3 cached"},
42 LscCacheValidValue{0xC, CacheOpt::STREAMING, CacheOpt::CACHED, CacheOpt::UNCACHED,
43 ".st.ca.uc", "L1 streaming, L2 cached, L3 uncached"},
44 LscCacheValidValue{0xD, CacheOpt::STREAMING, CacheOpt::CACHED, CacheOpt::CACHED,
45 ".st.ca.ca", "L1 streaming, L2 cached, L3 cached"},
46 LscCacheValidValue{0xE, CacheOpt::READINVALIDATE, CacheOpt::READINVALIDATE, CacheOpt::READINVALIDATE,
47 ".ri.ri.ri", "L1 read-invalidate, L2 read-invalidate, L3 read-invalidate"}
48 };
49
50 static const LscCacheValidValue LSC_CACHING_ST[]{
51 LscCacheValidValue{0x0, CacheOpt::DEFAULT, CacheOpt::DEFAULT, CacheOpt::DEFAULT,
52 ".df.df.df", "L1 state, L2 MOCS, L3 MOCS"},
53 LscCacheValidValue{0x2, CacheOpt::UNCACHED, CacheOpt::UNCACHED, CacheOpt::UNCACHED,
54 ".uc.uc.uc", "L1 uncached, L2 uncached, L3 uncached"},
55 LscCacheValidValue{0x3, CacheOpt::UNCACHED, CacheOpt::UNCACHED, CacheOpt::WRITEBACK,
56 ".uc.uc.wb", "L1 uncached, L2 uncached, L3 writeback"},
57 LscCacheValidValue{0x4, CacheOpt::UNCACHED, CacheOpt::WRITEBACK, CacheOpt::UNCACHED,
58 ".uc.wb.uc", "L1 uncached, L2 writeback, L3 uncached"},
59 LscCacheValidValue{0x5, CacheOpt::UNCACHED, CacheOpt::WRITEBACK, CacheOpt::WRITEBACK,
60 ".uc.wb.wb", "L1 uncached, L2 writeback, L3 writeback"},
61 LscCacheValidValue{0x6, CacheOpt::WRITETHROUGH, CacheOpt::UNCACHED, CacheOpt::UNCACHED,
62 ".wt.uc.uc", "L1 writethrough, L2 uncached, L3 uncached"},
63 LscCacheValidValue{0x7, CacheOpt::WRITETHROUGH, CacheOpt::UNCACHED, CacheOpt::WRITEBACK,
64 ".wt.uc.wb", "L1 writethrough, L2 uncached, L3 writeback"},
65 LscCacheValidValue{0x8, CacheOpt::WRITETHROUGH, CacheOpt::WRITEBACK, CacheOpt::UNCACHED,
66 ".wt.wb.uc", "L1 writethrough, L2 writeback, L3 uncached"},
67 LscCacheValidValue{0x9, CacheOpt::WRITETHROUGH, CacheOpt::WRITEBACK, CacheOpt::WRITEBACK,
68 ".wt.wb.wb", "L1 writethrough, L2 writeback, L3 writeback"},
69 LscCacheValidValue{0xA, CacheOpt::STREAMING, CacheOpt::UNCACHED, CacheOpt::UNCACHED,
70 ".st.uc.uc", "L1 streaming, L2 uncached, L3 uncached"},
71 LscCacheValidValue{0xB, CacheOpt::STREAMING, CacheOpt::UNCACHED, CacheOpt::WRITEBACK,
72 ".st.uc.wb", "L1 streaming, L2 uncached, L3 writeback"},
73 LscCacheValidValue{0xC, CacheOpt::STREAMING, CacheOpt::WRITEBACK, CacheOpt::UNCACHED,
74 ".st.wb.uc", "L1 streaming, L2 writeback, L3 uncached"},
75 LscCacheValidValue{0xD, CacheOpt::WRITEBACK, CacheOpt::UNCACHED, CacheOpt::UNCACHED,
76 ".wb.uc.uc", "L1 writeback, L2 uncached, L3 uncached"},
77 LscCacheValidValue{0xE, CacheOpt::WRITEBACK, CacheOpt::WRITEBACK, CacheOpt::UNCACHED,
78 ".wb.wb.uc", "L1 writeback, L2 writeback, L3 uncached"},
79 LscCacheValidValue{0xF, CacheOpt::WRITEBACK, CacheOpt::UNCACHED, CacheOpt::WRITEBACK,
80 ".wb.uc.wb", "L1 writeback, L2 uncached, L3 writeback"}
81 };
82
83 static const LscCacheValidValue LSC_CACHING_AT[]{
84 LscCacheValidValue{0x0, CacheOpt::DEFAULT, CacheOpt::DEFAULT, CacheOpt::DEFAULT,
85 ".df.df.df", "L1 state, L2 MOCS, L3 MOCS"},
86 LscCacheValidValue{0x2, CacheOpt::UNCACHED, CacheOpt::UNCACHED, CacheOpt::UNCACHED,
87 ".uc.uc.uc", "L1 uncached, L2 uncached, L3 uncached"},
88 LscCacheValidValue{0x3, CacheOpt::UNCACHED, CacheOpt::UNCACHED, CacheOpt::WRITEBACK,
89 ".uc.uc.wb", "L1 uncached, L2 uncached, L3 writeback"},
90 LscCacheValidValue{0x4, CacheOpt::UNCACHED, CacheOpt::WRITEBACK, CacheOpt::UNCACHED,
91 ".uc.wb.uc", "L1 uncached, L2 writeback, L3 uncached"}
92 };
93
94 ///////////////////////////////////////////////////////////////////////////////
95 MessageDecoderE64::MessageDecoderE64(Platform _platform, SFID _sfid,
96 ExecSize _instExecSize,
97 int _src0Len, int _src1Len,
98 uint64_t _desc, RegRef id0,
99 RegRef id1, DecodeResult &_result)
100 : decodeModel(Model::LookupModelRef(_platform)), sfid(_sfid),
101 execSize(_instExecSize), src0Len(_src0Len), src1Len(_src1Len),
102 desc(_desc), indDesc0(id0), indDesc1(id1),
103 //
104 result(_result)
105 //
106 {
107 result.info.execWidth =
108 _instExecSize != ExecSize::INVALID ? int(_instExecSize) : 0;
109 }
110
111 // Descriptor Bits[19:16]: 4 bits of cache control
112 const LscCacheValidValue *
113 MessageDecoderE64::decodeCacheControlValue(SendOp sop) {
114 ///////////////////////////////////////////////////////
115 // Cache Opt
116 // Value for bits[19:17]
117 const auto ccBits = getDescBits(16, 4);
118 const auto &opInfo = lookupSendOp(sop);
119 auto searchTable = [&](const LscCacheValidValue *table,
120 size_t tlen) -> const LscCacheValidValue * {
121 for (size_t i = 0; i < tlen; i++) {
122 if (table[i].encoding == ccBits) {
123 addField("Caching", 16, 4, ccBits, table[i].desc);
124 return &table[i];
125 }
126 }
127 return nullptr;
128 };
129
130 const LscCacheValidValue *desc = nullptr;
131 if (opInfo.isLoad() || opInfo.isSample() || opInfo.isCCtrl()) {
132 desc = searchTable(LSC_CACHING_LD,
133 sizeof(LSC_CACHING_LD) / sizeof(LSC_CACHING_LD[0]));
134 } else if (opInfo.isStore()) {
135 desc = searchTable(LSC_CACHING_ST,
136 sizeof(LSC_CACHING_ST) / sizeof(LSC_CACHING_ST[0]));
137 } else if (opInfo.isAtomic()) {
138 desc = searchTable(LSC_CACHING_AT,
139 sizeof(LSC_CACHING_AT) / sizeof(LSC_CACHING_AT[0]));
140 }
141 if (desc == nullptr) {
142 error(16, 4, "invalid caching option");
143 }
144 //
145 return desc;
146 } // decodeLscCacheControl
147
148 std::string MessageDecoderE64::decodeVectorSizeCmask(const char SYN[4]) {
149 auto mask = getDescBits(7, 4);
150 std::stringstream sss;
151 sss << ".";
152 std::stringstream mss;
153 int epa = 0;
154 for (int i = 0; i < 4; i++) {
155 if ((1 << i) & mask) {
156 if (epa != 0)
157 mss << ", ";
158 epa++;
159 mss << SYN[i];
160 sss << SYN[i];
161 }
162 }
163 if (mask == 0)
164 sss << "<empty>";
165 result.info.elemsPerAddr = epa;
166 result.info.channelsEnabled = mask;
167
168 std::string s = epa == 1 ? "" : "s";
169 addField("ComponentMask", 7, 4, mask, "load channel" + s + " " + mss.str());
170 return sss.str();
171 }
172
173 void MessageDecoderE64::decodeSsIdx() {
174 IGA_ASSERT(result.info.addrType == AddrType::SURF,
175 "SS_IDX only exists on surface messages");
176 auto enc = getDescBits(22, 5);
177 std::stringstream mss;
178 mss << "+" << enc
179 << " SURFACE_STATE entries "
180 "to state addr in IND0";
181 addField("Surface State Index", 22, 5, enc, mss.str());
182 result.info.surfaceStateIndex = enc;
183 }
184
185 void MessageDecoderE64::decodeSmsIdx() {
186 IGA_ASSERT(result.info.addrType == AddrType::SURF,
187 "SMS_IDX only exists on sampler messages");
188 auto enc = getDescBits(27, 3);
189 std::stringstream mss;
190 mss << "+" << enc
191 << " SAMPLER_STATE entries "
192 "to state addr in IND1";
193 addField("Sampler State Index", 27, 3, enc, mss.str());
194 result.info.samplerStateIndex = enc;
195 }
196
197 void MessageDecoderE64::decodeUvrOffsets() {
198 auto decodeCoord = [&](const char *field, char which, int off) {
199 auto encU = getDescBits(off, 4);
200 int encS = getSignedBits<int32_t>(encU, 0, 4);
201 std::stringstream mss;
202 mss << "add " << encS << " to " << which << " coordinates";
203 addField(field, off, 4, encU, mss.str());
204 return encS;
205 };
206 result.info.uvrImmediateOffsets[0] = decodeCoord("U Offset", 'U', 38);
207 result.info.uvrImmediateOffsets[1] = decodeCoord("V Offset", 'V', 34);
208 result.info.uvrImmediateOffsets[2] = decodeCoord("R Offset", 'R', 30);
209 if (result.info.uvrImmediateOffsets[0] ||
210 result.info.uvrImmediateOffsets[1] ||
211 result.info.uvrImmediateOffsets[2]) {
212 std::stringstream ss;
213 ss << "(";
214 for (int i = 0; i < 3; i++) {
215 if (i > 0)
216 ss << ",";
217 ss << result.info.uvrImmediateOffsets[i];
218 }
219 ss << ")";
220 result.syntax.immOffset += ss.str();
221 }
222 }
223
224 std::string MessageDecoderE64::decodeSurfaceTypeHint() {
225 std::string sym{};
226 decodeField("SurfaceTypeHint", 11, 3,
227 [&] (uint32_t val, std::stringstream &ss) {
228 auto set = [&](std::string_view syn, std::string_view desc) {
229 ss << desc;
230 sym = std::string(syn);
231 };
232 switch (val) {
233 case 0: set("", "NO_HINT"); break;
234 case 1: set(".buf", "BUFFER"); break;
235 case 2: set(".t1d", "1D_1DARRAY"); break;
236 case 3: set(".t2d", "2D_2DARRAY"); break;
237 case 4: set(".3d", "3D"); break;
238 case 5: set(".cube", "CUBE"); break;
239 case 6: set(".cubea", "CUBEARRAY"); break;
240 default:
241 set("." + fmtHex(val) + "?", "???");
242 break;
243 }
244 result.syntax.controls += sym;
245 });
246 return sym;
247 }
248
249 void MessageDecoderE64::constructSurfaceSyntax() {
250 if (result.info.addrType != AddrType::SURF) {
251 return;
252 }
253 std::stringstream sss;
254 sss << "surf[";
255 if (indDesc0 == REGREF_INVALID) {
256 sss << "?";
257 } else {
258 sss << "s" << indDesc0.regNum << "." << indDesc0.subRegNum;
259 }
260 if (result.info.surfaceStateIndex) {
261 sss << "," << result.info.surfaceStateIndex;
262 }
263 sss << "]";
264
265 if (indDesc1 != REGREF_INVALID) {
266 sss << "[";
267 sss << ",";
268 sss << "s" << indDesc1.regNum << "." << indDesc1.subRegNum;
269 if (result.info.samplerStateIndex) {
270 sss << "," << result.info.samplerStateIndex;
271 }
272 sss << "]";
273 }
274 result.syntax.surface = sss.str();
275 }