• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- AMDGPUMetadata.h ---------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 /// \file
11 /// AMDGPU metadata definitions and in-memory representations.
12 ///
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_SUPPORT_AMDGPUMETADATA_H
17 #define LLVM_SUPPORT_AMDGPUMETADATA_H
18 
19 #include <cstdint>
20 #include <string>
21 #include <system_error>
22 #include <vector>
23 
24 namespace llvm {
25 namespace AMDGPU {
26 
27 //===----------------------------------------------------------------------===//
28 // HSA metadata.
29 //===----------------------------------------------------------------------===//
30 namespace HSAMD {
31 
32 /// HSA metadata major version.
33 constexpr uint32_t VersionMajor = 1;
34 /// HSA metadata minor version.
35 constexpr uint32_t VersionMinor = 0;
36 
37 /// HSA metadata beginning assembler directive.
38 constexpr char AssemblerDirectiveBegin[] = ".amd_amdgpu_hsa_metadata";
39 /// HSA metadata ending assembler directive.
40 constexpr char AssemblerDirectiveEnd[] = ".end_amd_amdgpu_hsa_metadata";
41 
42 /// Access qualifiers.
43 enum class AccessQualifier : uint8_t {
44   Default   = 0,
45   ReadOnly  = 1,
46   WriteOnly = 2,
47   ReadWrite = 3,
48   Unknown   = 0xff
49 };
50 
51 /// Address space qualifiers.
52 enum class AddressSpaceQualifier : uint8_t {
53   Private  = 0,
54   Global   = 1,
55   Constant = 2,
56   Local    = 3,
57   Generic  = 4,
58   Region   = 5,
59   Unknown  = 0xff
60 };
61 
62 /// Value kinds.
63 enum class ValueKind : uint8_t {
64   ByValue                = 0,
65   GlobalBuffer           = 1,
66   DynamicSharedPointer   = 2,
67   Sampler                = 3,
68   Image                  = 4,
69   Pipe                   = 5,
70   Queue                  = 6,
71   HiddenGlobalOffsetX    = 7,
72   HiddenGlobalOffsetY    = 8,
73   HiddenGlobalOffsetZ    = 9,
74   HiddenNone             = 10,
75   HiddenPrintfBuffer     = 11,
76   HiddenDefaultQueue     = 12,
77   HiddenCompletionAction = 13,
78   Unknown                = 0xff
79 };
80 
81 /// Value types.
82 enum class ValueType : uint8_t {
83   Struct  = 0,
84   I8      = 1,
85   U8      = 2,
86   I16     = 3,
87   U16     = 4,
88   F16     = 5,
89   I32     = 6,
90   U32     = 7,
91   F32     = 8,
92   I64     = 9,
93   U64     = 10,
94   F64     = 11,
95   Unknown = 0xff
96 };
97 
98 //===----------------------------------------------------------------------===//
99 // Kernel Metadata.
100 //===----------------------------------------------------------------------===//
101 namespace Kernel {
102 
103 //===----------------------------------------------------------------------===//
104 // Kernel Attributes Metadata.
105 //===----------------------------------------------------------------------===//
106 namespace Attrs {
107 
108 namespace Key {
109 /// Key for Kernel::Attr::Metadata::mReqdWorkGroupSize.
110 constexpr char ReqdWorkGroupSize[] = "ReqdWorkGroupSize";
111 /// Key for Kernel::Attr::Metadata::mWorkGroupSizeHint.
112 constexpr char WorkGroupSizeHint[] = "WorkGroupSizeHint";
113 /// Key for Kernel::Attr::Metadata::mVecTypeHint.
114 constexpr char VecTypeHint[] = "VecTypeHint";
115 /// Key for Kernel::Attr::Metadata::mRuntimeHandle.
116 constexpr char RuntimeHandle[] = "RuntimeHandle";
117 } // end namespace Key
118 
119 /// In-memory representation of kernel attributes metadata.
120 struct Metadata final {
121   /// 'reqd_work_group_size' attribute. Optional.
122   std::vector<uint32_t> mReqdWorkGroupSize = std::vector<uint32_t>();
123   /// 'work_group_size_hint' attribute. Optional.
124   std::vector<uint32_t> mWorkGroupSizeHint = std::vector<uint32_t>();
125   /// 'vec_type_hint' attribute. Optional.
126   std::string mVecTypeHint = std::string();
127   /// External symbol created by runtime to store the kernel address
128   /// for enqueued blocks.
129   std::string mRuntimeHandle = std::string();
130 
131   /// Default constructor.
132   Metadata() = default;
133 
134   /// \returns True if kernel attributes metadata is empty, false otherwise.
emptyfinal135   bool empty() const {
136     return !notEmpty();
137   }
138 
139   /// \returns True if kernel attributes metadata is not empty, false otherwise.
notEmptyfinal140   bool notEmpty() const {
141     return !mReqdWorkGroupSize.empty() || !mWorkGroupSizeHint.empty() ||
142            !mVecTypeHint.empty() || !mRuntimeHandle.empty();
143   }
144 };
145 
146 } // end namespace Attrs
147 
148 //===----------------------------------------------------------------------===//
149 // Kernel Argument Metadata.
150 //===----------------------------------------------------------------------===//
151 namespace Arg {
152 
153 namespace Key {
154 /// Key for Kernel::Arg::Metadata::mName.
155 constexpr char Name[] = "Name";
156 /// Key for Kernel::Arg::Metadata::mTypeName.
157 constexpr char TypeName[] = "TypeName";
158 /// Key for Kernel::Arg::Metadata::mSize.
159 constexpr char Size[] = "Size";
160 /// Key for Kernel::Arg::Metadata::mAlign.
161 constexpr char Align[] = "Align";
162 /// Key for Kernel::Arg::Metadata::mValueKind.
163 constexpr char ValueKind[] = "ValueKind";
164 /// Key for Kernel::Arg::Metadata::mValueType.
165 constexpr char ValueType[] = "ValueType";
166 /// Key for Kernel::Arg::Metadata::mPointeeAlign.
167 constexpr char PointeeAlign[] = "PointeeAlign";
168 /// Key for Kernel::Arg::Metadata::mAddrSpaceQual.
169 constexpr char AddrSpaceQual[] = "AddrSpaceQual";
170 /// Key for Kernel::Arg::Metadata::mAccQual.
171 constexpr char AccQual[] = "AccQual";
172 /// Key for Kernel::Arg::Metadata::mActualAccQual.
173 constexpr char ActualAccQual[] = "ActualAccQual";
174 /// Key for Kernel::Arg::Metadata::mIsConst.
175 constexpr char IsConst[] = "IsConst";
176 /// Key for Kernel::Arg::Metadata::mIsRestrict.
177 constexpr char IsRestrict[] = "IsRestrict";
178 /// Key for Kernel::Arg::Metadata::mIsVolatile.
179 constexpr char IsVolatile[] = "IsVolatile";
180 /// Key for Kernel::Arg::Metadata::mIsPipe.
181 constexpr char IsPipe[] = "IsPipe";
182 } // end namespace Key
183 
184 /// In-memory representation of kernel argument metadata.
185 struct Metadata final {
186   /// Name. Optional.
187   std::string mName = std::string();
188   /// Type name. Optional.
189   std::string mTypeName = std::string();
190   /// Size in bytes. Required.
191   uint32_t mSize = 0;
192   /// Alignment in bytes. Required.
193   uint32_t mAlign = 0;
194   /// Value kind. Required.
195   ValueKind mValueKind = ValueKind::Unknown;
196   /// Value type. Required.
197   ValueType mValueType = ValueType::Unknown;
198   /// Pointee alignment in bytes. Optional.
199   uint32_t mPointeeAlign = 0;
200   /// Address space qualifier. Optional.
201   AddressSpaceQualifier mAddrSpaceQual = AddressSpaceQualifier::Unknown;
202   /// Access qualifier. Optional.
203   AccessQualifier mAccQual = AccessQualifier::Unknown;
204   /// Actual access qualifier. Optional.
205   AccessQualifier mActualAccQual = AccessQualifier::Unknown;
206   /// True if 'const' qualifier is specified. Optional.
207   bool mIsConst = false;
208   /// True if 'restrict' qualifier is specified. Optional.
209   bool mIsRestrict = false;
210   /// True if 'volatile' qualifier is specified. Optional.
211   bool mIsVolatile = false;
212   /// True if 'pipe' qualifier is specified. Optional.
213   bool mIsPipe = false;
214 
215   /// Default constructor.
216   Metadata() = default;
217 };
218 
219 } // end namespace Arg
220 
221 //===----------------------------------------------------------------------===//
222 // Kernel Code Properties Metadata.
223 //===----------------------------------------------------------------------===//
224 namespace CodeProps {
225 
226 namespace Key {
227 /// Key for Kernel::CodeProps::Metadata::mKernargSegmentSize.
228 constexpr char KernargSegmentSize[] = "KernargSegmentSize";
229 /// Key for Kernel::CodeProps::Metadata::mGroupSegmentFixedSize.
230 constexpr char GroupSegmentFixedSize[] = "GroupSegmentFixedSize";
231 /// Key for Kernel::CodeProps::Metadata::mPrivateSegmentFixedSize.
232 constexpr char PrivateSegmentFixedSize[] = "PrivateSegmentFixedSize";
233 /// Key for Kernel::CodeProps::Metadata::mKernargSegmentAlign.
234 constexpr char KernargSegmentAlign[] = "KernargSegmentAlign";
235 /// Key for Kernel::CodeProps::Metadata::mWavefrontSize.
236 constexpr char WavefrontSize[] = "WavefrontSize";
237 /// Key for Kernel::CodeProps::Metadata::mNumSGPRs.
238 constexpr char NumSGPRs[] = "NumSGPRs";
239 /// Key for Kernel::CodeProps::Metadata::mNumVGPRs.
240 constexpr char NumVGPRs[] = "NumVGPRs";
241 /// Key for Kernel::CodeProps::Metadata::mMaxFlatWorkGroupSize.
242 constexpr char MaxFlatWorkGroupSize[] = "MaxFlatWorkGroupSize";
243 /// Key for Kernel::CodeProps::Metadata::mIsDynamicCallStack.
244 constexpr char IsDynamicCallStack[] = "IsDynamicCallStack";
245 /// Key for Kernel::CodeProps::Metadata::mIsXNACKEnabled.
246 constexpr char IsXNACKEnabled[] = "IsXNACKEnabled";
247 /// Key for Kernel::CodeProps::Metadata::mNumSpilledSGPRs.
248 constexpr char NumSpilledSGPRs[] = "NumSpilledSGPRs";
249 /// Key for Kernel::CodeProps::Metadata::mNumSpilledVGPRs.
250 constexpr char NumSpilledVGPRs[] = "NumSpilledVGPRs";
251 } // end namespace Key
252 
253 /// In-memory representation of kernel code properties metadata.
254 struct Metadata final {
255   /// Size in bytes of the kernarg segment memory. Kernarg segment memory
256   /// holds the values of the arguments to the kernel. Required.
257   uint64_t mKernargSegmentSize = 0;
258   /// Size in bytes of the group segment memory required by a workgroup.
259   /// This value does not include any dynamically allocated group segment memory
260   /// that may be added when the kernel is dispatched. Required.
261   uint32_t mGroupSegmentFixedSize = 0;
262   /// Size in bytes of the private segment memory required by a workitem.
263   /// Private segment memory includes arg, spill and private segments. Required.
264   uint32_t mPrivateSegmentFixedSize = 0;
265   /// Maximum byte alignment of variables used by the kernel in the
266   /// kernarg memory segment. Required.
267   uint32_t mKernargSegmentAlign = 0;
268   /// Wavefront size. Required.
269   uint32_t mWavefrontSize = 0;
270   /// Total number of SGPRs used by a wavefront. Optional.
271   uint16_t mNumSGPRs = 0;
272   /// Total number of VGPRs used by a workitem. Optional.
273   uint16_t mNumVGPRs = 0;
274   /// Maximum flat work-group size supported by the kernel. Optional.
275   uint32_t mMaxFlatWorkGroupSize = 0;
276   /// True if the generated machine code is using a dynamically sized
277   /// call stack. Optional.
278   bool mIsDynamicCallStack = false;
279   /// True if the generated machine code is capable of supporting XNACK.
280   /// Optional.
281   bool mIsXNACKEnabled = false;
282   /// Number of SGPRs spilled by a wavefront. Optional.
283   uint16_t mNumSpilledSGPRs = 0;
284   /// Number of VGPRs spilled by a workitem. Optional.
285   uint16_t mNumSpilledVGPRs = 0;
286 
287   /// Default constructor.
288   Metadata() = default;
289 
290   /// \returns True if kernel code properties metadata is empty, false
291   /// otherwise.
emptyfinal292   bool empty() const {
293     return !notEmpty();
294   }
295 
296   /// \returns True if kernel code properties metadata is not empty, false
297   /// otherwise.
notEmptyfinal298   bool notEmpty() const {
299     return true;
300   }
301 };
302 
303 } // end namespace CodeProps
304 
305 //===----------------------------------------------------------------------===//
306 // Kernel Debug Properties Metadata.
307 //===----------------------------------------------------------------------===//
308 namespace DebugProps {
309 
310 namespace Key {
311 /// Key for Kernel::DebugProps::Metadata::mDebuggerABIVersion.
312 constexpr char DebuggerABIVersion[] = "DebuggerABIVersion";
313 /// Key for Kernel::DebugProps::Metadata::mReservedNumVGPRs.
314 constexpr char ReservedNumVGPRs[] = "ReservedNumVGPRs";
315 /// Key for Kernel::DebugProps::Metadata::mReservedFirstVGPR.
316 constexpr char ReservedFirstVGPR[] = "ReservedFirstVGPR";
317 /// Key for Kernel::DebugProps::Metadata::mPrivateSegmentBufferSGPR.
318 constexpr char PrivateSegmentBufferSGPR[] = "PrivateSegmentBufferSGPR";
319 /// Key for
320 ///     Kernel::DebugProps::Metadata::mWavefrontPrivateSegmentOffsetSGPR.
321 constexpr char WavefrontPrivateSegmentOffsetSGPR[] =
322     "WavefrontPrivateSegmentOffsetSGPR";
323 } // end namespace Key
324 
325 /// In-memory representation of kernel debug properties metadata.
326 struct Metadata final {
327   /// Debugger ABI version. Optional.
328   std::vector<uint32_t> mDebuggerABIVersion = std::vector<uint32_t>();
329   /// Consecutive number of VGPRs reserved for debugger use. Must be 0 if
330   /// mDebuggerABIVersion is not set. Optional.
331   uint16_t mReservedNumVGPRs = 0;
332   /// First fixed VGPR reserved. Must be uint16_t(-1) if
333   /// mDebuggerABIVersion is not set or mReservedFirstVGPR is 0. Optional.
334   uint16_t mReservedFirstVGPR = uint16_t(-1);
335   /// Fixed SGPR of the first of 4 SGPRs used to hold the scratch V# used
336   /// for the entire kernel execution. Must be uint16_t(-1) if
337   /// mDebuggerABIVersion is not set or SGPR not used or not known. Optional.
338   uint16_t mPrivateSegmentBufferSGPR = uint16_t(-1);
339   /// Fixed SGPR used to hold the wave scratch offset for the entire
340   /// kernel execution. Must be uint16_t(-1) if mDebuggerABIVersion is not set
341   /// or SGPR is not used or not known. Optional.
342   uint16_t mWavefrontPrivateSegmentOffsetSGPR = uint16_t(-1);
343 
344   /// Default constructor.
345   Metadata() = default;
346 
347   /// \returns True if kernel debug properties metadata is empty, false
348   /// otherwise.
emptyfinal349   bool empty() const {
350     return !notEmpty();
351   }
352 
353   /// \returns True if kernel debug properties metadata is not empty, false
354   /// otherwise.
notEmptyfinal355   bool notEmpty() const {
356     return !mDebuggerABIVersion.empty();
357   }
358 };
359 
360 } // end namespace DebugProps
361 
362 namespace Key {
363 /// Key for Kernel::Metadata::mName.
364 constexpr char Name[] = "Name";
365 /// Key for Kernel::Metadata::mSymbolName.
366 constexpr char SymbolName[] = "SymbolName";
367 /// Key for Kernel::Metadata::mLanguage.
368 constexpr char Language[] = "Language";
369 /// Key for Kernel::Metadata::mLanguageVersion.
370 constexpr char LanguageVersion[] = "LanguageVersion";
371 /// Key for Kernel::Metadata::mAttrs.
372 constexpr char Attrs[] = "Attrs";
373 /// Key for Kernel::Metadata::mArgs.
374 constexpr char Args[] = "Args";
375 /// Key for Kernel::Metadata::mCodeProps.
376 constexpr char CodeProps[] = "CodeProps";
377 /// Key for Kernel::Metadata::mDebugProps.
378 constexpr char DebugProps[] = "DebugProps";
379 } // end namespace Key
380 
381 /// In-memory representation of kernel metadata.
382 struct Metadata final {
383   /// Kernel source name. Required.
384   std::string mName = std::string();
385   /// Kernel descriptor name. Required.
386   std::string mSymbolName = std::string();
387   /// Language. Optional.
388   std::string mLanguage = std::string();
389   /// Language version. Optional.
390   std::vector<uint32_t> mLanguageVersion = std::vector<uint32_t>();
391   /// Attributes metadata. Optional.
392   Attrs::Metadata mAttrs = Attrs::Metadata();
393   /// Arguments metadata. Optional.
394   std::vector<Arg::Metadata> mArgs = std::vector<Arg::Metadata>();
395   /// Code properties metadata. Optional.
396   CodeProps::Metadata mCodeProps = CodeProps::Metadata();
397   /// Debug properties metadata. Optional.
398   DebugProps::Metadata mDebugProps = DebugProps::Metadata();
399 
400   /// Default constructor.
401   Metadata() = default;
402 };
403 
404 } // end namespace Kernel
405 
406 namespace Key {
407 /// Key for HSA::Metadata::mVersion.
408 constexpr char Version[] = "Version";
409 /// Key for HSA::Metadata::mPrintf.
410 constexpr char Printf[] = "Printf";
411 /// Key for HSA::Metadata::mKernels.
412 constexpr char Kernels[] = "Kernels";
413 } // end namespace Key
414 
415 /// In-memory representation of HSA metadata.
416 struct Metadata final {
417   /// HSA metadata version. Required.
418   std::vector<uint32_t> mVersion = std::vector<uint32_t>();
419   /// Printf metadata. Optional.
420   std::vector<std::string> mPrintf = std::vector<std::string>();
421   /// Kernels metadata. Required.
422   std::vector<Kernel::Metadata> mKernels = std::vector<Kernel::Metadata>();
423 
424   /// Default constructor.
425   Metadata() = default;
426 };
427 
428 /// Converts \p String to \p HSAMetadata.
429 std::error_code fromString(std::string String, Metadata &HSAMetadata);
430 
431 /// Converts \p HSAMetadata to \p String.
432 std::error_code toString(Metadata HSAMetadata, std::string &String);
433 
434 } // end namespace HSAMD
435 
436 //===----------------------------------------------------------------------===//
437 // PAL metadata.
438 //===----------------------------------------------------------------------===//
439 namespace PALMD {
440 
441 /// PAL metadata assembler directive.
442 constexpr char AssemblerDirective[] = ".amd_amdgpu_pal_metadata";
443 
444 /// PAL metadata keys.
445 enum Key : uint32_t {
446   LS_NUM_USED_VGPRS = 0x10000021,
447   HS_NUM_USED_VGPRS = 0x10000022,
448   ES_NUM_USED_VGPRS = 0x10000023,
449   GS_NUM_USED_VGPRS = 0x10000024,
450   VS_NUM_USED_VGPRS = 0x10000025,
451   PS_NUM_USED_VGPRS = 0x10000026,
452   CS_NUM_USED_VGPRS = 0x10000027,
453 
454   LS_NUM_USED_SGPRS = 0x10000028,
455   HS_NUM_USED_SGPRS = 0x10000029,
456   ES_NUM_USED_SGPRS = 0x1000002a,
457   GS_NUM_USED_SGPRS = 0x1000002b,
458   VS_NUM_USED_SGPRS = 0x1000002c,
459   PS_NUM_USED_SGPRS = 0x1000002d,
460   CS_NUM_USED_SGPRS = 0x1000002e,
461 
462   LS_SCRATCH_SIZE = 0x10000044,
463   HS_SCRATCH_SIZE = 0x10000045,
464   ES_SCRATCH_SIZE = 0x10000046,
465   GS_SCRATCH_SIZE = 0x10000047,
466   VS_SCRATCH_SIZE = 0x10000048,
467   PS_SCRATCH_SIZE = 0x10000049,
468   CS_SCRATCH_SIZE = 0x1000004a
469 };
470 
471 /// PAL metadata represented as a vector.
472 typedef std::vector<uint32_t> Metadata;
473 
474 /// Converts \p PALMetadata to \p String.
475 std::error_code toString(const Metadata &PALMetadata, std::string &String);
476 
477 } // end namespace PALMD
478 } // end namespace AMDGPU
479 } // end namespace llvm
480 
481 #endif // LLVM_SUPPORT_AMDGPUMETADATA_H
482