1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
|
/*========================== begin_copyright_notice ============================
Copyright (C) 2023 Intel Corporation
SPDX-License-Identifier: MIT
============================= end_copyright_notice ===========================*/
// A file containing the table of supported g4::MsgOp's for simple
// C Preprpocessor meta programming. Other files will #include this to
// create case statements, tables, whatnot. The typical use case will
// involve multiple #includes. Unlike other headers this file is expected
// to be #included multiple times.
//
// Near the top of the use file where needed one should #include it with no
// special processing.
// ... other headers
// #include "G4_MsgOpDefs.hpp"
// ... other headers
// ...
// This will cause the file to define various types needed by the table callback.
//
// Later in the file one can define various preprocessor callbacks.
//
// #define DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, ATTRS) SYNTAX,
// const char *opNames[] {
// #include "G4_MsgOpDefs.hpp" // expands to all the syntax symbols
// // undefs DEFINE_G4_MSGOP
// };
//
// The callback can be used multiple times.
//
// #define DEFINE_G4_MSGOP_LSC_LOAD(SYMBOL, SYNTAX, ENCODING, ATTRS) ENCODING,
// const int justLscLoadEncodings[] {
// #include "G4_MsgOpDefs.hpp"
// // expands to all the encodings of LSC_LOAD; drops the rest
// // the #include undefs DEFINE_G4_MSGOP_LSC_LOAD
// };
#ifndef G4_MSGOP_TYPES_DEFINED
#define G4_MSGOP_TYPES_DEFINED
// These are various bits used in symbolic definitions of message operations
// That enable one to create packed enumation definitions
// Messages have a "group" and "attributes".
//
// Groups roughly correspond to SFIDs messages are defined on.
// Attributes hold generic predicates corresponding to messages such as
// if a message has a data channel mask.
// Since, messages might target different SFIDs on different platforms
// extra scrutiny might be needed as messages get moved around.
static const int MSGOP_GROUP_LSC_LOAD = 0x001;
static const int MSGOP_GROUP_LSC_STORE = (MSGOP_GROUP_LSC_LOAD << 1);
static const int MSGOP_GROUP_LSC_ATOMIC = (MSGOP_GROUP_LSC_STORE << 1);
static const int MSGOP_GROUP_LSC_OTHER = (MSGOP_GROUP_LSC_ATOMIC << 1);
static const int MSGOP_GROUP_GTWY = (MSGOP_GROUP_LSC_OTHER << 1);
static const int MSGOP_GROUP_SMPL_NORMAL = (MSGOP_GROUP_GTWY << 1);
static const int MSGOP_GROUP_SMPL_GATHER = (MSGOP_GROUP_SMPL_NORMAL << 1);
static const int MSGOP_GROUP_SMPL_OTHER = (MSGOP_GROUP_SMPL_GATHER << 1);
static const int MSGOP_GROUP_RENDER = (MSGOP_GROUP_SMPL_OTHER << 1);
static const int MSGOP_GROUP_RTA = (MSGOP_GROUP_RENDER << 1);
static const int MSGOP_GROUP_BTD = (MSGOP_GROUP_RTA << 1);
static_assert((MSGOP_GROUP_BTD & ~0xFFF) == 0, "group field overflowed");
// e.g. load_quad, store_quad, ...
static const int MSGOP_ATTRS_EMPTY = 0x0000;
static const int MSGOP_ATTRS_HAS_CMASK = 0x0001;
static const int MSGOP_ATTRS_ATOMIC_UNARY = MSGOP_ATTRS_HAS_CMASK << 1;
static const int MSGOP_ATTRS_ATOMIC_BINARY = MSGOP_ATTRS_ATOMIC_UNARY << 1;
static const int MSGOP_ATTRS_ATOMIC_TERNARY = MSGOP_ATTRS_ATOMIC_BINARY << 1;
// other attributes here (NOTE: can overlap based on group)
#endif // G4_MSGOP_TYPES_DEFINED
// DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, GROUP, ATTRS)
// The top-level macro callback. The more specific variants cover to this.
// A user can define this to capture all messages or define lower level
// macros to filter based on group.
//
// * SYMBOL a symbol to use in an enum (e.g. LOAD)
// * SYNTAX a string to use in output (e.g. "load")
// * ENCODING a an integer encoding for for this operation (typically Desc[5:0])
// * GROUP a group ordinal value grouping this message; a bit set of 12b (0xXXX)
// * ATTRS a bitset of attributes (at least a byte)
#ifndef DEFINE_G4_MSGOP
#define DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, GROUP, ATTRS)
#endif
#ifndef DEFINE_G4_MSGOP_LSC_LOAD
#define DEFINE_G4_MSGOP_LSC_LOAD(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_LSC_LOAD, ATTRS)
#endif // DEFINE_G4_MSGOP_LOAD_GROUP
#ifndef DEFINE_G4_MSGOP_LSC_STORE
#define DEFINE_G4_MSGOP_LSC_STORE(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_LSC_STORE, ATTRS)
#endif // DEFINE_G4_MSGOP_LSC_STORE
#ifndef DEFINE_G4_MSGOP_LSC_ATOMIC
#define DEFINE_G4_MSGOP_LSC_ATOMIC(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_LSC_ATOMIC, ATTRS)
#endif // DEFINE_G4_MSGOP_LSC_ATOMIC
#ifndef DEFINE_G4_MSGOP_LSC_OTHER
#define DEFINE_G4_MSGOP_LSC_OTHER(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_LSC_OTHER, ATTRS)
#endif // DEFINE_G4_MSGOP_LSC_OTHER
#ifndef DEFINE_G4_MSGOP_GTWY
#define DEFINE_G4_MSGOP_GTWY(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_GTWY, ATTRS)
#endif // DEFINE_G4_MSGOP_GTWY
#ifndef DEFINE_G4_MSGOP_SMPL_NORMAL
#define DEFINE_G4_MSGOP_SMPL_NORMAL(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_SMPL_NORMAL, ATTRS)
#endif // DEFINE_G4_MSGOP_SMPL_NORMAL
#ifndef DEFINE_G4_MSGOP_SMPL_GATHER
#define DEFINE_G4_MSGOP_SMPL_GATHER(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_SMPL_GATHER, ATTRS)
#endif // DEFINE_G4_MSGOP_SMPL_GATHER
#ifndef DEFINE_G4_MSGOP_SMPL_OTHER
#define DEFINE_G4_MSGOP_SMPL_OTHER(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_SMPL_OTHER, ATTRS)
#endif // DEFINE_G4_MSGOP_SMPL_OTHER
#ifndef DEFINE_G4_MSGOP_RENDER
#define DEFINE_G4_MSGOP_RENDER(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_RENDER, ATTRS)
#endif // DEFINE_G4_MSGOP_RENDER
#ifndef DEFINE_G4_MSGOP_RTA
#define DEFINE_G4_MSGOP_RTA(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_RTA, ATTRS)
#endif // DEFINE_G4_MSGOP_RTA
#ifndef DEFINE_G4_MSGOP_BTD
#define DEFINE_G4_MSGOP_BTD(SYMBOL, SYNTAX, ENCODING, ATTRS) \
DEFINE_G4_MSGOP(SYMBOL, SYNTAX, ENCODING, MSGOP_GROUP_BTD, ATTRS)
#endif // DEFINE_G4_MSGOP_BTD
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// The callback table
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// LSC loads
DEFINE_G4_MSGOP_LSC_LOAD(LOAD, "load", 0x00,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_STRIDED, "load_strided", 0x01,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_QUAD, "load_quad", 0x02,
MSGOP_ATTRS_HAS_CMASK)
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_QUAD_MSRT, "load_quad_msrt", 0x31,
MSGOP_ATTRS_HAS_CMASK)
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_STATUS, "load_status", 0x1B,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_LSC_LOAD(LOAD_BLOCK2D, "load_block2d", 0x03,
MSGOP_ATTRS_EMPTY)
///////////////////////////////////////////////////////////////////////////////
// LSC stores
DEFINE_G4_MSGOP_LSC_STORE(STORE, "store", 0x04,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_LSC_STORE(STORE_STRIDED, "store_strided", 0x05,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_LSC_STORE(STORE_QUAD, "store_quad", 0x06,
MSGOP_ATTRS_HAS_CMASK)
DEFINE_G4_MSGOP_LSC_STORE(STORE_QUAD_MSRT, "store_quad_msrt", 0x32,
MSGOP_ATTRS_HAS_CMASK)
DEFINE_G4_MSGOP_LSC_STORE(STORE_BLOCK2D, "store_block2d", 0x07,
MSGOP_ATTRS_EMPTY)
///////////////////////////////////////////////////////////////////////////////
// LSC atomics
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_IINC, "atomic_iinc", 0x08,
MSGOP_ATTRS_ATOMIC_UNARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_IDEC, "atomic_idec", 0x09,
MSGOP_ATTRS_ATOMIC_UNARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_LOAD, "atomic_load", 0x0A,
MSGOP_ATTRS_ATOMIC_UNARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_STORE, "atomic_store", 0x0B,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_IADD, "atomic_iadd", 0x0C,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ISUB, "atomic_isub", 0x0D,
MSGOP_ATTRS_ATOMIC_BINARY)
//
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_SMIN, "atomic_smin", 0x0E,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_SMAX, "atomic_smax", 0x0F,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_UMIN, "atomic_umin", 0x10,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_UMAX, "atomic_umax", 0x11,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ICAS, "atomic_icas", 0x12,
MSGOP_ATTRS_ATOMIC_TERNARY)
//
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FADD, "atomic_fadd", 0x13,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FSUB, "atomic_fsub", 0x14,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FMIN, "atomic_fmin", 0x15,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FMAX, "atomic_fmax", 0x16,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_FCAS, "atomic_fcas", 0x17,
MSGOP_ATTRS_ATOMIC_TERNARY)
//
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_AND, "atomic_and", 0x18,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_OR, "atomic_or", 0x19,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_XOR, "atomic_xor", 0x1A,
MSGOP_ATTRS_ATOMIC_BINARY)
//
// setting this to binary as src0 is null and src1 is the data operand
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ACADD, "atomic_acadd", 0x28,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ACSUB, "atomic_acsub", 0x29,
MSGOP_ATTRS_ATOMIC_BINARY)
DEFINE_G4_MSGOP_LSC_ATOMIC(ATOMIC_ACSTORE, "atomic_store", 0x2A,
MSGOP_ATTRS_ATOMIC_BINARY)
///////////////////////////////////////////////////////////////////////////////
// LSC other
DEFINE_G4_MSGOP_LSC_OTHER(RSI, "rsi", 0x1E,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_LSC_OTHER(FENCE, "fence", 0x1F,
MSGOP_ATTRS_EMPTY)
///////////////////////////////////////////////////////////////////////////////
// gateway ops
DEFINE_G4_MSGOP_GTWY(EOT, "eot", 0x00, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_GTWY(EOTR, "eotr", 0x0A, MSGOP_ATTRS_EMPTY)
//
DEFINE_G4_MSGOP_GTWY(BARRIER_SIGNAL, "barrier_signal", 0x04,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_GTWY(BARRIER_SIGNAL_NAMED, "barrier_signal_named", 0x05,
MSGOP_ATTRS_EMPTY)
///////////////////////////////////////////////////////////////////////////////
// sampler ops
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE, "sample", 0x00, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_B, "sample_b", 0x01, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_L, "sample_l", 0x02, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_C, "sample_c", 0x03, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_D, "sample_d", 0x04, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_B_C, "sample_b_c", 0x05,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_L_C, "sample_l_c", 0x06,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_KILLPIX, "sample_killpix", 0x0C,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_D_C, "sample_d_c", 0x14, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_LZ, "sample_lz", 0x18, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_C_LZ, "sample_c_lz", 0x19,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_MLOD, "sample_mlod", 0x12,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_C_MLOD, "sample_c_mlod", 0x13,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_D_C_MLOD, "sample_d_c_mlod", 0x11,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO, "sample_po", 0x20, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_B, "sample_po_b", 0x21,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_L, "sample_po_l", 0x22,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_C, "sample_po_c", 0x23,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_D, "sample_po_d", 0x24,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_L_C, "sample_po_l_c", 0x26,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_LZ, "sample_po_lz", 0x38,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_NORMAL(SAMPLE_PO_C_LZ, "sample_po_c_lz", 0x39,
MSGOP_ATTRS_EMPTY)
////////////////////////////////
// gather 4 sampler ops
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4, "gather4", 0x08, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_C, "gather4_c", 0x10, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_L, "gather4_l", 0x0D, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_B, "gather4_b", 0x0E, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_I, "gather4_i", 0x0F, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_I_C, "gather4_i_c", 0x15,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_L_C, "gather4_l_c", 0x17,
MSGOP_ATTRS_EMPTY)
//
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO, "gather4_po", 0x28,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_L, "gather4_po_l", 0x2D,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_B, "gather4_po_b", 0x2E,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_I, "gather4_po_i", 0x2F,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_C, "gather4_po_c", 0x30,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_I_C, "gather4_po_i_c", 0x35,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_GATHER(GATHER4_PO_L_C, "gather4_po_l_c", 0x37,
MSGOP_ATTRS_EMPTY)
////////////////////////////////
// other sampler messages
DEFINE_G4_MSGOP_SMPL_OTHER(LD, "ld", 0x07, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_OTHER(LOD, "lod", 0x09, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_OTHER(RESINFO, "resinfo", 0x0A, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_OTHER(SAMPLE_INFO, "sample_info", 0x0B,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_OTHER(LD_LZ, "ld_lz", 0x1A, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_OTHER(LD_2DMS_W, "ld_2dms_w", 0x1C, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_OTHER(LD_MCS, "ld_mcs", 0x1D, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_OTHER(SAMPLER_FLUSH, "sampler_flush", 0x1F,
MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_SMPL_OTHER(LD_L, "ld_l", 0x1B, MSGOP_ATTRS_EMPTY)
//
///////////////////////////////////////////////////////////////////////////////
// render target ops
DEFINE_G4_MSGOP_RENDER(READ, "read", 0x02, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_RENDER(WRITE, "write", 0x06, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_RENDER(DUAL_WRITE, "dual_write", 0x05, MSGOP_ATTRS_EMPTY)
///////////////////////////////////////////////////////////////////////////////
// btd ops and ray tracing
DEFINE_G4_MSGOP_RTA(TRACE_RAY, "trace_ray", 0x00, MSGOP_ATTRS_EMPTY)
//
DEFINE_G4_MSGOP_BTD(SPAWN, "spawn", 0x00, MSGOP_ATTRS_EMPTY)
DEFINE_G4_MSGOP_BTD(STACK_ID_RELEASE, "stack_id_release", 0x01,
MSGOP_ATTRS_EMPTY)
///////////////////////////////////////////////////////////////////////////////
// #undef anything that was defined, including by the #include'r so
// that the callback can be used again elsewhere.
#ifdef DEFINE_G4_MSGOP
#undef DEFINE_G4_MSGOP
#endif
#ifdef DEFINE_G4_MSGOP_LSC_LOAD
#undef DEFINE_G4_MSGOP_LSC_LOAD
#endif
#ifdef DEFINE_G4_MSGOP_LSC_STORE
#undef DEFINE_G4_MSGOP_LSC_STORE
#endif
#ifdef DEFINE_G4_MSGOP_LSC_ATOMIC
#undef DEFINE_G4_MSGOP_LSC_ATOMIC
#endif
#ifdef DEFINE_G4_MSGOP_LSC_OTHER
#undef DEFINE_G4_MSGOP_LSC_OTHER
#endif
#ifdef DEFINE_G4_MSGOP_GTWY
#undef DEFINE_G4_MSGOP_GTWY
#endif
#ifdef DEFINE_G4_MSGOP_SMPL_NORMAL
#undef DEFINE_G4_MSGOP_SMPL_NORMAL
#endif
#ifdef DEFINE_G4_MSGOP_SMPL_GATHER
#undef DEFINE_G4_MSGOP_SMPL_GATHER
#endif
#ifdef DEFINE_G4_MSGOP_SMPL_OTHER
#undef DEFINE_G4_MSGOP_SMPL_OTHER
#endif
#ifdef DEFINE_G4_MSGOP_RENDER
#undef DEFINE_G4_MSGOP_RENDER
#endif
#ifdef DEFINE_G4_MSGOP_RTA
#undef DEFINE_G4_MSGOP_RTA
#endif
#ifdef DEFINE_G4_MSGOP_BTD
#undef DEFINE_G4_MSGOP_BTD
#endif
|
