Debian Codegraph @

IGC/AdaptorOCL/ocl_igc_shared/executable_format/patch_shared.h

raw
1 /*========================== begin_copyright_notice ============================
2
3 Copyright (C) 2017-2022 Intel Corporation
4
5 SPDX-License-Identifier: MIT
6
7 ============================= end_copyright_notice ===========================*/
8
9 #pragma once
10 #include <stdint.h>
11 #include "patch_list.h"
12
13 #pragma pack(push, 1)
14
15 namespace iOpenCL {
16 /*****************************************************************************\
17 STRUCT: SPatchStateSIP
18 \*****************************************************************************/
19 struct SPatchStateSIP : SPatchItemHeader {
20 uint32_t SystemKernelOffset;
21 };
22
23 // Update CURRENT_ICBE_VERSION when modifying the patch list
24 static_assert(sizeof(SPatchStateSIP) == (4 + sizeof(SPatchItemHeader)),
25 "The size of SPatchStateSIP is not what is expected");
26
27 /*****************************************************************************\
28 STRUCT: SPatchSamplerStateArray
29 \*****************************************************************************/
30 struct SPatchSamplerStateArray : SPatchItemHeader {
31 uint32_t Offset;
32 uint32_t Count;
33 uint32_t BorderColorOffset;
34 };
35
36 // Update CURRENT_ICBE_VERSION when modifying the patch list
37 static_assert(sizeof(SPatchSamplerStateArray) == (12 + sizeof(SPatchItemHeader)),
38 "The size of SPatchSamplerStateArray is not what is expected");
39
40 /*****************************************************************************\
41 STRUCT: SPatchBindingTableState
42 \*****************************************************************************/
43 struct SPatchBindingTableState : SPatchItemHeader {
44 uint32_t Offset;
45 uint32_t Count;
46 uint32_t SurfaceStateOffset;
47 };
48
49 // Update CURRENT_ICBE_VERSION when modifying the patch list
50 static_assert(sizeof(SPatchBindingTableState) == (12 + sizeof(SPatchItemHeader)),
51 "The size of SPatchBindingTableState is not what is expected");
52
53 /*****************************************************************************\
54 STRUCT: SPatchAllocateScratchSurface
55 \*****************************************************************************/
56 struct SPatchAllocateScratchSurface : SPatchItemHeader {
57 uint32_t Offset;
58 uint32_t PerThreadScratchSpaceSize;
59 };
60
61 // Update CURRENT_ICBE_VERSION when modifying the patch list
62 static_assert(sizeof(SPatchAllocateScratchSurface) == (8 + sizeof(SPatchItemHeader)),
63 "The size of SPatchAllocateScratchSurface is not what is expected");
64
65 /*****************************************************************************\
66 STRUCT: SPatchAllocatePrivateMemorySurface
67 \*****************************************************************************/
68 struct SPatchAllocatePrivateMemorySurface : SPatchItemHeader {
69 uint32_t Offset;
70 uint32_t PerThreadPrivateMemorySize;
71 };
72
73 // Update CURRENT_ICBE_VERSION when modifying the patch list
74 static_assert(sizeof(SPatchAllocatePrivateMemorySurface) == (8 + sizeof(SPatchItemHeader)),
75 "The size of SPatchAllocatePrivateMemorySurface is not what is expected");
76
77 /*****************************************************************************\
78 STRUCT: SPatchAllocateSystemThreadSurface
79 \*****************************************************************************/
80 struct SPatchAllocateSystemThreadSurface : SPatchItemHeader {
81 uint32_t Offset;
82 uint32_t PerThreadSystemThreadSurfaceSize;
83 uint32_t BTI;
84 };
85
86 // Update CURRENT_ICBE_VERSION when modifying the patch list
87 static_assert(sizeof(SPatchAllocateSystemThreadSurface) == (12 + sizeof(SPatchItemHeader)),
88 "The size of SPatchAllocateSystemThreadSurface is not what is expected");
89
90 /*****************************************************************************\
91 STRUCT: SPatchAllocateSurfaceWithInitialization
92 \*****************************************************************************/
93 struct SPatchAllocateSurfaceWithInitialization : SPatchItemHeader {
94 uint32_t Offset;
95 uint32_t InitializationDataSize;
96 };
97
98 // Update CURRENT_ICBE_VERSION when modifying the patch list
99 static_assert(sizeof(SPatchAllocateSurfaceWithInitialization) == (8 + sizeof(SPatchItemHeader)),
100 "The size of SPatchAllocateSurfaceWithInitialization is not what is expected");
101
102 /*****************************************************************************\
103 STRUCT: SPatchAllocateConstantMemorySurfaceWithInitialization
104 \*****************************************************************************/
105 struct SPatchAllocateConstantMemorySurfaceWithInitialization : SPatchItemHeader {
106 uint32_t ConstantBufferIndex;
107 uint32_t Offset;
108 #if 0 // needed for CB2CR - need RT buy off.
109 uint32_t InlineConstantBufferIndex;
110 #endif
111 };
112
113 // Update CURRENT_ICBE_VERSION when modifying the patch list
114 static_assert(sizeof(SPatchAllocateConstantMemorySurfaceWithInitialization) == (8 + sizeof(SPatchItemHeader)),
115 "The size of SPatchAllocateConstantMemorySurfaceWithInitialization is not what is expected");
116
117 /*****************************************************************************\
118 STRUCT: SPatchAllocateLocalSurface
119 \*****************************************************************************/
120 struct SPatchAllocateLocalSurface : SPatchItemHeader {
121 uint32_t Offset;
122 uint32_t TotalInlineLocalMemorySize;
123 };
124
125 // Update CURRENT_ICBE_VERSION when modifying the patch list
126 static_assert(sizeof(SPatchAllocateLocalSurface) == (8 + sizeof(SPatchItemHeader)),
127 "The size of SPatchAllocateLocalSurface is not what is expected");
128
129 /*****************************************************************************\
130 STRUCT: SPatchThreadPayload
131 \*****************************************************************************/
132 struct SPatchThreadPayload : SPatchItemHeader {
133 uint32_t HeaderPresent;
134 uint32_t LocalIDXPresent;
135 uint32_t LocalIDYPresent;
136 uint32_t LocalIDZPresent;
137 uint32_t LocalIDFlattenedPresent;
138 uint32_t IndirectPayloadStorage;
139 uint32_t UnusedPerThreadConstantPresent;
140 uint32_t GetLocalIDPresent;
141 uint32_t GetGroupIDPresent;
142 uint32_t GetGlobalOffsetPresent;
143 uint32_t StageInGridOriginPresent;
144 uint32_t StageInGridSizePresent;
145 uint32_t OffsetToSkipPerThreadDataLoad;
146 uint32_t OffsetToSkipSetFFIDGP;
147 uint32_t PassInlineData;
148 uint32_t RTStackIDPresent;
149 uint32_t generateLocalID;
150 uint32_t emitLocalMask;
151 uint32_t walkOrder;
152 uint32_t tileY;
153 };
154
155 // Update CURRENT_ICBE_VERSION when modifying the patch list
156 static_assert(sizeof(SPatchThreadPayload) == (80 + sizeof(SPatchItemHeader)),
157 "The size of SPatchThreadPayload is not what is expected");
158
159 /*****************************************************************************\
160 STRUCT: SPatchExecutionEnvironment
161 \*****************************************************************************/
162 struct SPatchExecutionEnvironment : SPatchItemHeader {
163 uint32_t RequiredWorkGroupSizeX;
164 uint32_t RequiredWorkGroupSizeY;
165 uint32_t RequiredWorkGroupSizeZ;
166 uint32_t LargestCompiledSIMDSize;
167 uint32_t CompiledSubGroupsNumber;
168 uint32_t HasBarriers;
169 uint32_t HasSample;
170 uint32_t DisableMidThreadPreemption;
171 uint32_t CompiledSIMD8;
172 uint32_t CompiledSIMD16;
173 uint32_t CompiledSIMD32;
174 uint32_t HasDeviceEnqueue;
175 uint32_t MayAccessUndeclaredResource;
176 uint32_t UsesFencesForReadWriteImages;
177 uint32_t UsesStatelessSpillFill;
178 uint32_t UsesMultiScratchSpaces;
179 uint32_t IsCoherent;
180 uint32_t IsInitializer;
181 uint32_t IsFinalizer;
182 uint32_t SubgroupIndependentForwardProgressRequired;
183 uint32_t CompiledForGreaterThan4GBBuffers;
184 uint32_t NumGRFRequired;
185 uint32_t WorkgroupWalkOrderDims; // dim0 : [0 : 1]; dim1 : [2 : 3]; dim2 : [4 : 5]
186 uint32_t HasGlobalAtomics;
187 uint32_t HasDPAS;
188 uint32_t HasRTCalls; // Raytracing extensions used in kernel.
189 uint32_t NumThreadsRequired;
190 uint32_t StatelessWritesCount;
191 uint32_t IndirectStatelessCount;
192 uint32_t UseBindlessMode;
193 uint32_t HasStackCalls;
194 uint64_t SIMDInfo;
195 uint32_t RequireDisableEUFusion;
196 };
197
198 // Update CURRENT_ICBE_VERSION when modifying the patch list
199 static_assert(sizeof(SPatchExecutionEnvironment) == (136 + sizeof(SPatchItemHeader)),
200 "The size of SPatchExecutionEnvironment is not what is expected");
201
202 /*****************************************************************************\
203 STRUCT: SPatchString
204 \*****************************************************************************/
205 struct SPatchString : SPatchItemHeader {
206 uint32_t Index;
207 uint32_t StringSize;
208 };
209
210 // Update CURRENT_ICBE_VERSION when modifying the patch list
211 static_assert(sizeof(SPatchString) == (8 + sizeof(SPatchItemHeader)),
212 "The size of SPatchString is not what is expected");
213
214 /*****************************************************************************\
215 STRUCT: SPatchAllocatePrintfSurface
216 \*****************************************************************************/
217 struct SPatchAllocatePrintfSurface : SPatchItemHeader {
218 uint32_t PrintfSurfaceIndex;
219 uint32_t Offset;
220 };
221
222 // Update CURRENT_ICBE_VERSION when modifying the patch list
223 static_assert(sizeof(SPatchAllocatePrintfSurface) == (8 + sizeof(SPatchItemHeader)),
224 "The size of SPatchAllocatePrintfSurface is not what is expected");
225
226 /*****************************************************************************\
227 STRUCT: SPatchAllocateGlobalMemorySurfaceWithInitialization
228 \*****************************************************************************/
229 struct SPatchAllocateGlobalMemorySurfaceWithInitialization : SPatchItemHeader {
230 uint32_t GlobalBufferIndex;
231 uint32_t Offset;
232 };
233
234 // Update CURRENT_ICBE_VERSION when modifying the patch list
235 static_assert(sizeof(SPatchAllocateGlobalMemorySurfaceWithInitialization) == (8 + sizeof(SPatchItemHeader)),
236 "The size of SPatchAllocateGlobalMemorySurfaceWithInitialization is not what is expected");
237
238 /*****************************************************************************\
239 STRUCT: SPatchCB2CRGatherTable
240 \*****************************************************************************/
241 struct SPatchCB2CRGatherTable : SPatchItemHeader {
242 uint32_t NumberOfEntries;
243 uint32_t Offset;
244 };
245
246 // Update CURRENT_ICBE_VERSION when modifying the patch list
247 static_assert(sizeof(SPatchCB2CRGatherTable) == (8 + sizeof(SPatchItemHeader)),
248 "The size of SPatchCB2CRGatherTable is not what is expected");
249
250 /*****************************************************************************\
251 STRUCT: SPatchCB2KernelArgument
252 \*****************************************************************************/
253 struct SPatchConstantBufferMapping : SPatchItemHeader {
254 uint32_t ConstantBufferType;
255 uint32_t ConstantBufferIndex;
256 uint32_t ConstantBufferId;
257 };
258
259 // Update CURRENT_ICBE_VERSION when modifying the patch list
260 static_assert(sizeof(SPatchConstantBufferMapping) == (12 + sizeof(SPatchItemHeader)),
261 "The size of SPatchConstantBufferMapping is not what is expected");
262
263 /*****************************************************************************\
264 STRUCT: SPatchStatelessGlobalMemoryObjectKernelArgument
265 \*****************************************************************************/
266 struct SPatchStatelessGlobalMemoryObjectKernelArgument : SPatchItemHeader {
267 uint32_t ArgumentNumber;
268 uint32_t SurfaceStateHeapOffset;
269 uint32_t DataParamOffset;
270 uint32_t DataParamSize;
271 uint32_t LocationIndex;
272 uint32_t LocationIndex2;
273 uint32_t IsEmulationArgument;
274 };
275
276 // Update CURRENT_ICBE_VERSION when modifying the patch list
277 static_assert(sizeof(SPatchStatelessGlobalMemoryObjectKernelArgument) == (28 + sizeof(SPatchItemHeader)),
278 "The size of SPatchStatelessGlobalMemoryObjectKernelArgument is not what is expected");
279
280 /*****************************************************************************\
281 STRUCT: SPatchStatelessConstantMemoryObjectKernelArgument
282 \*****************************************************************************/
283 struct SPatchStatelessConstantMemoryObjectKernelArgument : SPatchItemHeader {
284 uint32_t ArgumentNumber;
285 uint32_t SurfaceStateHeapOffset;
286 uint32_t DataParamOffset;
287 uint32_t DataParamSize;
288 uint32_t LocationIndex;
289 uint32_t LocationIndex2;
290 uint32_t IsEmulationArgument;
291 };
292
293 // Update CURRENT_ICBE_VERSION when modifying the patch list
294 static_assert(sizeof(SPatchStatelessConstantMemoryObjectKernelArgument) == (28 + sizeof(SPatchItemHeader)),
295 "The size of SPatchStatelessConstantMemoryObjectKernelArgument is not what is expected");
296
297 /*****************************************************************************\
298 STRUCT: SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization
299 \*****************************************************************************/
300 struct SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization : SPatchItemHeader {
301 uint32_t GlobalBufferIndex;
302 uint32_t SurfaceStateHeapOffset;
303 uint32_t DataParamOffset;
304 uint32_t DataParamSize;
305 };
306
307 // Update CURRENT_ICBE_VERSION when modifying the patch list
308 static_assert(sizeof(SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization) == (16 + sizeof(SPatchItemHeader)),
309 "The size of SPatchAllocateStatelessGlobalMemorySurfaceWithInitialization is not what is expected");
310
311 /*****************************************************************************\
312 STRUCT: SPatchAllocateStatelessConstantMemorySurfaceWithInitialization
313 \*****************************************************************************/
314 struct SPatchAllocateStatelessConstantMemorySurfaceWithInitialization : SPatchItemHeader {
315 uint32_t ConstantBufferIndex;
316 uint32_t SurfaceStateHeapOffset;
317 uint32_t DataParamOffset;
318 uint32_t DataParamSize;
319 };
320
321 // Update CURRENT_ICBE_VERSION when modifying the patch list
322 static_assert(sizeof(SPatchAllocateStatelessConstantMemorySurfaceWithInitialization) == (16 + sizeof(SPatchItemHeader)),
323 "The size of SPatchAllocateStatelessConstantMemorySurfaceWithInitialization is not what is expected");
324
325 /*****************************************************************************\
326 STRUCT: SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo
327 \*****************************************************************************/
328 struct SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo : SPatchItemHeader {
329 uint32_t Type;
330 uint32_t GlobalBufferIndex;
331 uint32_t InlineDataSize;
332 };
333
334 // Update CURRENT_ICBE_VERSION when modifying the patch list
335 static_assert(sizeof(SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo) == (12 + sizeof(SPatchItemHeader)),
336 "The size of SPatchAllocateGlobalMemorySurfaceProgramBinaryInfo is not what is expected");
337
338 /*****************************************************************************\
339 STRUCT: SPatchKernelTypeProgramBinaryInfo
340 \*****************************************************************************/
341 struct SPatchKernelTypeProgramBinaryInfo : SPatchItemHeader {
342 uint32_t Type; // constructor or destructor
343 uint32_t InlineDataSize; // size of kernel name for constructor/desctructor
344 };
345
346 // Update CURRENT_ICBE_VERSION when modifying the patch list
347 static_assert(sizeof(SPatchKernelTypeProgramBinaryInfo) == (8 + sizeof(SPatchItemHeader)),
348 "The size of SPatchKernelTypeProgramBinaryInfo is not what is expected");
349
350 /*****************************************************************************\
351 STRUCT: SPatchInlineVMESamplerInfo
352 \*****************************************************************************/
353 struct SPatchInlineVMESamplerInfo : SPatchItemHeader {};
354
355 // Update CURRENT_ICBE_VERSION when modifying the patch list
356 static_assert(sizeof(SPatchInlineVMESamplerInfo) == (sizeof(SPatchItemHeader)),
357 "The size of SPatchInlineVMESamplerInfo is not what is expected");
358
359 /*****************************************************************************\
360 STRUCT: SPatchAllocateConstantMemorySurfaceProgramBinaryInfo
361 \*****************************************************************************/
362 struct SPatchAllocateConstantMemorySurfaceProgramBinaryInfo : SPatchItemHeader {
363 uint32_t ConstantBufferIndex;
364 uint32_t InlineDataSize;
365 };
366
367 // Update CURRENT_ICBE_VERSION when modifying the patch list
368 static_assert(sizeof(SPatchAllocateConstantMemorySurfaceProgramBinaryInfo) == (8 + sizeof(SPatchItemHeader)),
369 "The size of SPatchAllocateConstantMemorySurfaceProgramBinaryInfo is not what is expected");
370
371 /*****************************************************************************\
372 STRUCT: SPatchGlobalPointerProgramBinaryInfo
373 \*****************************************************************************/
374 struct SPatchGlobalPointerProgramBinaryInfo : SPatchItemHeader {
375 uint32_t GlobalBufferIndex;
376 uint64_t GlobalPointerOffset;
377 uint32_t BufferType;
378 uint32_t BufferIndex;
379 };
380
381 // Update CURRENT_ICBE_VERSION when modifying the patch list
382 static_assert(sizeof(SPatchGlobalPointerProgramBinaryInfo) == (20 + sizeof(SPatchItemHeader)),
383 "The size of SPatchGlobalPointerProgramBinaryInfo is not what is expected");
384
385 /*****************************************************************************\
386 STRUCT: SPatchConstantPointerProgramBinaryInfo
387 \*****************************************************************************/
388 struct SPatchConstantPointerProgramBinaryInfo : SPatchItemHeader {
389 uint32_t ConstantBufferIndex;
390 uint64_t ConstantPointerOffset;
391 uint32_t BufferType;
392 uint32_t BufferIndex;
393 };
394
395 // Update CURRENT_ICBE_VERSION when modifying the patch list
396 static_assert(sizeof(SPatchConstantPointerProgramBinaryInfo) == (20 + sizeof(SPatchItemHeader)),
397 "The size of SPatchConstantPointerProgramBinaryInfo is not what is expected");
398
399 /*****************************************************************************\
400 STRUCT: SPatchAllocateStatelessPrintfSurface
401 \*****************************************************************************/
402 struct SPatchAllocateStatelessPrintfSurface : SPatchItemHeader {
403 uint32_t PrintfSurfaceIndex;
404 uint32_t SurfaceStateHeapOffset;
405 uint32_t DataParamOffset;
406 uint32_t DataParamSize;
407 };
408
409 // Update CURRENT_ICBE_VERSION when modifying the patch list
410 static_assert(sizeof(SPatchAllocateStatelessPrintfSurface) == (16 + sizeof(SPatchItemHeader)),
411 "The size of SPatchAllocateStatelessPrintfSurface is not what is expected");
412
413 struct SPatchAllocateSyncBuffer : SPatchItemHeader {
414 uint32_t SurfaceStateHeapOffset;
415 uint32_t DataParamOffset;
416 uint32_t DataParamSize;
417 };
418
419 // Update CURRENT_ICBE_VERSION when modifying the patch list
420 static_assert(sizeof(SPatchAllocateSyncBuffer) == (12 + sizeof(SPatchItemHeader)),
421 "The size of SPatchAllocateSyncBuffer is not what is expected");
422
423 // Raytracing
424 struct SPatchAllocateRTGlobalBuffer : SPatchItemHeader {
425 uint32_t SurfaceStateHeapOffset;
426 uint32_t DataParamOffset;
427 uint32_t DataParamSize;
428 };
429
430 // Update CURRENT_ICBE_VERSION when modifying the patch list
431 static_assert(sizeof(SPatchAllocateRTGlobalBuffer) == (12 + sizeof(SPatchItemHeader)),
432 "The size of SPatchAllocateRTGlobalBuffer is not what is expected");
433
434 /*****************************************************************************\
435 STRUCT: SPatchAllocateStatelessPrivateSurface
436 \*****************************************************************************/
437 struct SPatchAllocateStatelessPrivateSurface : SPatchItemHeader {
438 uint32_t SurfaceStateHeapOffset;
439 uint32_t DataParamOffset;
440 uint32_t DataParamSize;
441 uint32_t PerThreadPrivateMemorySize;
442 // if IsSimtThread is true, API assumes it is allocated per-simt-thread
443 // else, API assumes it's allocated per-hardware-thread
444 uint32_t IsSimtThread;
445 };
446
447 // Update CURRENT_ICBE_VERSION when modifying the patch list
448 static_assert(sizeof(SPatchAllocateStatelessPrivateSurface) == (20 + sizeof(SPatchItemHeader)),
449 "The size of SPatchAllocateStatelessPrivateSurface is not what is expected");
450
451 /*****************************************************************************\
452 STRUCT: SPatchMediaVFEState
453 \*****************************************************************************/
454 struct SPatchMediaVFEState : SPatchItemHeader {
455 uint32_t ScratchSpaceOffset;
456 uint32_t PerThreadScratchSpace;
457 };
458
459 // Update CURRENT_ICBE_VERSION when modifying the patch list
460 static_assert(sizeof(SPatchMediaVFEState) == (8 + sizeof(SPatchItemHeader)),
461 "The size of SPatchMediaVFEState is not what is expected");
462
463 /*****************************************************************************\
464 STRUCT: SPatchAllocateStatelessEventPoolSurface
465 \*****************************************************************************/
466 struct SPatchAllocateStatelessEventPoolSurface : SPatchItemHeader {
467 uint32_t EventPoolSurfaceIndex;
468 uint32_t SurfaceStateHeapOffset;
469 uint32_t DataParamOffset;
470 uint32_t DataParamSize;
471 };
472
473 // Update CURRENT_ICBE_VERSION when modifying the patch list
474 static_assert(sizeof(SPatchAllocateStatelessEventPoolSurface) == (16 + sizeof(SPatchItemHeader)),
475 "The size of SPatchAllocateStatelessEventPoolSurface is not what is expected");
476
477 /*****************************************************************************\
478 STRUCT: SPatchAllocateStatelessDefaultDeviceQueueSurface
479 \*****************************************************************************/
480 struct SPatchAllocateStatelessDefaultDeviceQueueSurface : SPatchItemHeader {
481 uint32_t SurfaceStateHeapOffset;
482 uint32_t DataParamOffset;
483 uint32_t DataParamSize;
484 };
485
486 // Update CURRENT_ICBE_VERSION when modifying the patch list
487 static_assert(sizeof(SPatchAllocateStatelessDefaultDeviceQueueSurface) == (12 + sizeof(SPatchItemHeader)),
488 "The size of SPatchAllocateStatelessDefaultDeviceQueueSurface is not what is expected");
489
490 /*****************************************************************************\
491 STRUCT: SPatchStatelessDeviceQueueKernelArgument
492 \*****************************************************************************/
493 struct SPatchStatelessDeviceQueueKernelArgument : SPatchItemHeader {
494 uint32_t ArgumentNumber;
495 uint32_t SurfaceStateHeapOffset;
496 uint32_t DataParamOffset;
497 uint32_t DataParamSize;
498 uint32_t LocationIndex;
499 uint32_t LocationIndex2;
500 uint32_t IsEmulationArgument;
501 };
502
503 // Update CURRENT_ICBE_VERSION when modifying the patch list
504 static_assert(sizeof(SPatchStatelessDeviceQueueKernelArgument) == (28 + sizeof(SPatchItemHeader)),
505 "The size of SPatchStatelessDeviceQueueKernelArgument is not what is expected");
506
507 /*****************************************************************************\
508 STRUCT: SPatchNullSurfaceLocation
509 \*****************************************************************************/
510 struct SPatchNullSurfaceLocation : SPatchItemHeader {
511 uint32_t Offset;
512 };
513
514 // Update CURRENT_ICBE_VERSION when modifying the patch list
515 static_assert(sizeof(SPatchNullSurfaceLocation) == (4 + sizeof(SPatchItemHeader)),
516 "The size of SPatchNullSurfaceLocation is not what is expected");
517
518 /*****************************************************************************\
519 STRUCT: SPatchGtpinFreeGRFInfo
520 \*****************************************************************************/
521 struct SPatchGtpinFreeGRFInfo : SPatchItemHeader {
522 uint32_t BufferSize;
523 };
524
525 // Update CURRENT_ICBE_VERSION when modifying the patch list
526 static_assert(sizeof(SPatchGtpinFreeGRFInfo) == (4 + sizeof(SPatchItemHeader)),
527 "The size of SPatchGtpinFreeGRFInfo is not what is expected");
528
529 /*****************************************************************************\
530 STRUCT: SPatchFunctionTableInfo
531 \*****************************************************************************/
532 struct SPatchFunctionTableInfo : SPatchItemHeader {
533 uint32_t NumEntries;
534 };
535
536 // Update CURRENT_ICBE_VERSION when modifying the patch list
537 static_assert(sizeof(SPatchFunctionTableInfo) == (4 + sizeof(SPatchItemHeader)),
538 "The size of SPatchFunctionTableInfo is not what is expected");
539
540 /*****************************************************************************\
541 STRUCT: SPatchGlobalHostAccessTableInfo
542 \*****************************************************************************/
543 struct SPatchGlobalHostAccessTableInfo : SPatchItemHeader {
544 uint32_t NumEntries;
545 };
546
547 // Update CURRENT_ICBE_VERSION when modifying the patch list
548 static_assert(sizeof(SPatchGlobalHostAccessTableInfo) == (4 + sizeof(SPatchItemHeader)),
549 "The size of SPatchGlobalHostAccessTableInfo is not what is expected");
550
551 } // namespace iOpenCL
552 #pragma pack(pop)