CLRX  1
An unofficial OpenCL extensions designed for Radeon GPUs
ROCmBinaries.h
Go to the documentation of this file.
1 /*
2  * CLRadeonExtender - Unofficial OpenCL Radeon Extensions Library
3  * Copyright (C) 2014-2018 Mateusz Szpakowski
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
23 #ifndef __CLRX_ROCMBINARIES_H__
24 #define __CLRX_ROCMBINARIES_H__
25 
26 #include <CLRX/Config.h>
27 #include <cstddef>
28 #include <cstdint>
29 #include <memory>
30 #include <string>
31 #include <vector>
32 #include <CLRX/amdbin/Elf.h>
34 #include <CLRX/amdbin/Commons.h>
35 #include <CLRX/utils/MemAccess.h>
36 #include <CLRX/utils/Containers.h>
37 #include <CLRX/utils/Utilities.h>
38 #include <CLRX/utils/GPUId.h>
39 #include <CLRX/utils/InputOutput.h>
40 
42 namespace CLRX
43 {
44 
45 enum : Flags {
50 };
51 
53 enum class ROCmRegionType: uint8_t
54 {
55  DATA,
56  FKERNEL,
57  KERNEL
58 };
59 
61 struct ROCmRegion
62 {
64  size_t size;
65  size_t offset;
67 };
68 
70 enum class ROCmValueKind : cxbyte
71 {
72  BY_VALUE = 0,
75  SAMPLER,
76  IMAGE,
77  PIPE,
78  QUEUE,
82  HIDDEN_NONE,
86  HIDDEN_MULTIGRID_SYNC_ARG,
87  MAX_VALUE = HIDDEN_MULTIGRID_SYNC_ARG
88 };
89 
91 enum class ROCmValueType : cxbyte
92 {
93  STRUCTURE = 0,
94  INT8,
95  UINT8,
96  INT16,
97  UINT16,
98  FLOAT16,
99  INT32,
100  UINT32,
101  FLOAT32,
102  INT64,
103  UINT64,
104  FLOAT64,
105  MAX_VALUE = FLOAT64
106 };
107 
110 {
111  NONE = 0,
112  PRIVATE,
113  GLOBAL,
114  CONSTANT,
115  LOCAL,
116  GENERIC,
117  REGION,
118  MAX_VALUE = REGION
119 };
120 
123 {
124  DEFAULT = 0,
125  READ_ONLY,
126  WRITE_ONLY,
127  READ_WRITE,
128  MAX_VALUE = READ_WRITE
129 };
130 
133 {
136  uint64_t size;
137  union {
138  uint64_t align;
139  uint64_t offset;
140  };
141  uint64_t pointeeAlign;
147  bool isConst;
148  bool isRestrict;
149  bool isVolatile;
150  bool isPipe;
151 };
152 
155 {
158  std::vector<ROCmKernelArgInfo> argInfos;
160  cxuint langVersion[2];
161  cxuint reqdWorkGroupSize[3];
162  cxuint workGroupSizeHint[3];
172  uint64_t maxFlatWorkGroupSize;
173  cxuint fixedWorkGroupSize[3];
176  CString deviceEnqueueSymbol;
177 
178  void initialize();
179 };
180 
183 {
184  uint32_t id;
187 };
188 
191 {
192  cxuint version[2];
193  std::vector<ROCmPrintfInfo> printfInfos;
194  std::vector<ROCmKernelMetadata> kernels;
195 
197  void initialize();
199  void parse(size_t metadataSize, const char* metadata);
201  void parseMsgPack(size_t metadataSize, const cxbyte* metadata);
202 };
203 
205 {
206  uint32_t groupSegmentFixedSize;
207  uint32_t privateSegmentFixedSize;
208  uint64_t reserved0;
209  uint64_t kernelCodeEntryOffset;
210  uint64_t reserved1;
211  cxbyte reserved2[12];
212  uint32_t pgmRsrc3;
213  uint32_t pgmRsrc1;
214  uint32_t pgmRsrc2;
215  uint16_t initialKernelExecState;
216  cxbyte reserved3[6];
217 
218  void toLE()
219  {
220  SLEV(groupSegmentFixedSize, groupSegmentFixedSize);
221  SLEV(privateSegmentFixedSize, privateSegmentFixedSize);
222  SLEV(kernelCodeEntryOffset, kernelCodeEntryOffset);
223  SLEV(pgmRsrc3, pgmRsrc3);
224  SLEV(pgmRsrc1, pgmRsrc1);
225  SLEV(pgmRsrc2, pgmRsrc2);
226  SLEV(initialKernelExecState, initialKernelExecState);
227  }
228 };
229 
231 
235 {
236 public:
239 private:
240  size_t regionsNum;
241  std::unique_ptr<ROCmRegion[]> regions;
242  RegionMap regionsMap;
243  size_t codeSize;
244  cxbyte* code;
245  size_t globalDataSize;
246  cxbyte* globalData;
247  CString target;
248  size_t metadataSize;
249  char* metadata;
250  std::unique_ptr<ROCmMetadata> metadataInfo;
251  RegionMap kernelInfosMap;
253  Array<size_t> gotSymbols;
254  bool newBinFormat;
255  bool llvm10BinFormat;
256  bool metadataV3Format;
257 public:
259  ROCmBinary(size_t binaryCodeSize, cxbyte* binaryCode,
260  Flags creationFlags = ROCMBIN_CREATE_ALL);
262  ~ROCmBinary() = default;
263 
265  GPUDeviceType determineGPUDeviceType(uint32_t& archMinor,
266  uint32_t& archStepping) const;
267 
269  size_t getRegionsNum() const
270  { return regionsNum; }
271 
273  const ROCmRegion& getRegion(size_t index) const
274  { return regions[index]; }
275 
277  const ROCmRegion& getRegion(const char* name) const;
278 
280  size_t getCodeSize() const
281  { return codeSize; }
283  const cxbyte* getCode() const
284  { return code; }
287  { return code; }
288 
290  size_t getGlobalDataSize() const
291  { return globalDataSize; }
292 
294  const cxbyte* getGlobalData() const
295  { return globalData; }
298  { return globalData; }
299 
301  size_t getMetadataSize() const
302  { return metadataSize; }
304  const char* getMetadata() const
305  { return metadata; }
307  char* getMetadata()
308  { return metadata; }
309 
311  bool hasMetadataInfo() const
312  { return metadataInfo!=nullptr; }
313 
316  { return *metadataInfo; }
317 
319  size_t getKernelInfosNum() const
320  { return metadataInfo->kernels.size(); }
321 
323  const ROCmKernelMetadata& getKernelInfo(size_t index) const
324  { return metadataInfo->kernels[index]; }
325 
327  const ROCmKernelMetadata& getKernelInfo(const char* name) const;
328 
330  const ROCmKernelDescriptor* getKernelDescriptor(size_t index) const
331  { return kernelDescs[index]; }
332  // get kernel descriptor by name
333  const ROCmKernelDescriptor* getKernelDescriptor(const char* name) const;
334 
336  const CString& getTarget() const
337  { return target; }
338 
340  bool isNewBinaryFormat() const
341  { return newBinFormat; }
342 
344  bool isLLVM10BinaryFormat() const
345  { return llvm10BinFormat; }
346 
348  bool isMetadataV3Format() const
349  { return metadataV3Format; }
350 
352  size_t getGotSymbolsNum() const
353  { return gotSymbols.size(); }
354 
357  { return gotSymbols; }
358 
360  size_t getGotSymbol(size_t index) const
361  { return gotSymbols[index]; }
362 
364  bool hasRegionMap() const
365  { return (creationFlags & ROCMBIN_CREATE_REGIONMAP) != 0; }
367  bool hasKernelInfoMap() const
368  { return (creationFlags & ROCMBIN_CREATE_KERNELINFOMAP) != 0; }
369 };
370 
371 enum {
372  ROCMFLAG_USE_PRIVATE_SEGMENT_BUFFER = AMDHSAFLAG_USE_PRIVATE_SEGMENT_BUFFER,
373  ROCMFLAG_USE_DISPATCH_PTR = AMDHSAFLAG_USE_DISPATCH_PTR,
374  ROCMFLAG_USE_QUEUE_PTR = AMDHSAFLAG_USE_QUEUE_PTR,
375  ROCMFLAG_USE_KERNARG_SEGMENT_PTR = AMDHSAFLAG_USE_KERNARG_SEGMENT_PTR,
376  ROCMFLAG_USE_DISPATCH_ID = AMDHSAFLAG_USE_DISPATCH_ID,
377  ROCMFLAG_USE_FLAT_SCRATCH_INIT = AMDHSAFLAG_USE_FLAT_SCRATCH_INIT,
378  ROCMFLAG_USE_PRIVATE_SEGMENT_SIZE = AMDHSAFLAG_USE_PRIVATE_SEGMENT_SIZE,
379  ROCMFLAG_USE_GRID_WORKGROUP_COUNT_BIT = AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_BIT,
380  ROCMFLAG_USE_GRID_WORKGROUP_COUNT_X = AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_X,
381  ROCMFLAG_USE_GRID_WORKGROUP_COUNT_Y = AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_Y,
382  ROCMFLAG_USE_GRID_WORKGROUP_COUNT_Z = AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_Z,
383  ROCMFLAG_USE_WAVE32 = AMDHSAFLAG_USE_WAVE32,
384 
385  ROCMFLAG_USE_ORDERED_APPEND_GDS = AMDHSAFLAG_USE_ORDERED_APPEND_GDS,
386  ROCMFLAG_PRIVATE_ELEM_SIZE_BIT = AMDHSAFLAG_PRIVATE_ELEM_SIZE_BIT,
387  ROCMFLAG_USE_PTR64 = AMDHSAFLAG_USE_PTR64,
388  ROCMFLAG_USE_DYNAMIC_CALL_STACK = AMDHSAFLAG_USE_DYNAMIC_CALL_STACK,
389  ROCMFLAG_USE_DEBUG_ENABLED = AMDHSAFLAG_USE_DEBUG_ENABLED,
390  ROCMFLAG_USE_XNACK_ENABLED = AMDHSAFLAG_USE_XNACK_ENABLED
391 };
392 
395 
397 extern bool isROCmBinary(size_t binarySize, const cxbyte* binary);
398 
399 /*
400  * ROCm Binary Generator
401  */
402 
403 enum: cxuint {
404  ROCMSECTID_HASH = ELFSECTID_OTHER_BUILTIN,
405  ROCMSECTID_DYNAMIC,
406  ROCMSECTID_NOTE,
407  ROCMSECTID_GPUCONFIG,
408  ROCMSECTID_RELADYN,
409  ROCMSECTID_GOT,
410  ROCMSECTID_MAX = ROCMSECTID_GOT
411 };
412 
415 {
417  size_t offset;
418  size_t size;
420 };
421 
423 struct ROCmInput
424 {
426  uint32_t archMinor;
427  uint32_t archStepping;
428  uint32_t eflags;
430  bool llvm10BinFormat;
431  bool metadataV3Format;
432  size_t globalDataSize;
434  std::vector<ROCmSymbolInput> symbols;
435  size_t codeSize;
436  const cxbyte* code;
437  size_t commentSize;
438  const char* comment;
441  size_t metadataSize;
442  const char* metadata;
445 
447 
451  std::vector<size_t> gotSymbols;
452  std::vector<BinSection> extraSections;
453  std::vector<BinSymbol> extraSymbols;
454 
456  void addEmptyKernel(const char* kernelName);
457 };
458 
461 {
462 private:
463  private:
464  bool manageable;
465  const ROCmInput* input;
466  std::unique_ptr<ElfBinaryGen64> elfBinGen64;
467  size_t binarySize;
468  size_t commentSize;
469  const char* comment;
470  std::string target;
471  std::unique_ptr<cxbyte[]> noteBuf;
472  std::string metadataStr;
473  std::vector<cxbyte> metadataBytes;
474  size_t metadataSize;
475  const char* metadata;
476  cxuint mainSectionsNum;
477  uint16_t mainBuiltinSectTable[ROCMSECTID_MAX-ELFSECTID_START+1];
478  void* rocmGotGen;
479  void* rocmRelaDynGen;
480  void* rocmLLVMGDataGen;
481  Array<CString> kdescSymNames;
482 
483  void generateInternal(std::ostream* osPtr, std::vector<char>* vPtr,
484  Array<cxbyte>* aPtr);
485 public:
489  explicit ROCmBinGenerator(const ROCmInput* rocmInput);
490 
492 
502  ROCmBinGenerator(GPUDeviceType deviceType, uint32_t archMinor, uint32_t archStepping,
503  size_t codeSize, const cxbyte* code,
504  size_t globalDataSize, const cxbyte* globalData,
505  const std::vector<ROCmSymbolInput>& symbols);
507  ROCmBinGenerator(GPUDeviceType deviceType, uint32_t archMinor, uint32_t archStepping,
508  size_t codeSize, const cxbyte* code,
509  size_t globalDataSize, const cxbyte* globalData,
510  std::vector<ROCmSymbolInput>&& symbols);
512  ~ROCmBinGenerator();
513 
515  const ROCmInput* getInput() const
516  { return input; }
518  void setInput(const ROCmInput* input);
519 
521  void prepareBinaryGen();
523  size_t getSectionOffset(cxuint sectionId) const
524  { return elfBinGen64->getRegionOffset(
525  mainBuiltinSectTable[sectionId - ELFSECTID_START]); }
527  void updateSymbols();
528 
530  void generate(Array<cxbyte>& array);
531 
533  void generate(std::ostream& os);
534 
536  void generate(std::vector<char>& vector);
537 };
538 
539 void generateROCmMetadata(const ROCmMetadata& mdInfo,
540  const ROCmKernelConfig** kconfigs, std::string& output);
541 
542 void generateROCmMetadataMsgPack(const ROCmMetadata& mdInfo,
543  const ROCmKernelDescriptor** kdescs, std::vector<cxbyte>& output);
544 
545 void parseROCmMetadata(size_t metadataSize, const char* metadata,
546  ROCmMetadata& metadataInfo);
547 
548 void parseROCmMetadataMsgPack(size_t metadataSize, const cxbyte* metadata,
549  ROCmMetadata& metadataInfo);
550 
551 class MsgPackMapParser;
552 
554 {
555 private:
556  const cxbyte*& dataPtr;
557  const cxbyte* dataEnd;
558  size_t count;
559  void handleErrors();
560 public:
561  MsgPackArrayParser(const cxbyte*& _dataPtr, const cxbyte* _dataEnd);
562 
563  void parseNil();
564  bool parseBool();
565  uint64_t parseInteger(cxbyte signess);
566  double parseFloat();
567  std::string parseString();
568  Array<cxbyte> parseData();
569  MsgPackArrayParser parseArray();
570  MsgPackMapParser parseMap();
571  size_t end(); // return left elements
572 
573  bool haveElements() const
574  { return count!=0; }
575 };
576 
577 enum: cxbyte {
578  MSGPACK_WS_UNSIGNED = 0, // only unsigned
579  MSGPACK_WS_SIGNED = 1, // only signed
580  MSGPACK_WS_BOTH = 2 // both signed and unsigned range checking
581 };
582 
584 {
585 private:
586  const cxbyte*& dataPtr;
587  const cxbyte* dataEnd;
588  size_t count;
589  bool keyLeft;
590  void handleErrors(bool key);
591 public:
592  MsgPackMapParser(const cxbyte*& _dataPtr, const cxbyte* _dataEnd);
593 
594  void parseKeyNil();
595  bool parseKeyBool();
596  uint64_t parseKeyInteger(cxbyte signess);
597  double parseKeyFloat();
598  std::string parseKeyString();
599  Array<cxbyte> parseKeyData();
600  MsgPackArrayParser parseKeyArray();
601  MsgPackMapParser parseKeyMap();
602  void parseValueNil();
603  bool parseValueBool();
604  uint64_t parseValueInteger(cxbyte signess);
605  double parseValueFloat();
606  std::string parseValueString();
607  Array<cxbyte> parseValueData();
608  MsgPackArrayParser parseValueArray();
609  MsgPackMapParser parseValueMap();
610  void skipValue();
611  size_t end(); // return left elements
612 
613  bool haveElements() const
614  { return count!=0; }
615 };
616 
617 class MsgPackMapWriter;
618 
620 {
621 private:
622  std::vector<cxbyte>& output;
623  size_t elemsNum;
624  size_t count;
625 public:
626  MsgPackArrayWriter(size_t elemsNum, std::vector<cxbyte>& output);
627 
628  void putBool(bool b);
629  void putString(const char* str);
630  void putUInt(uint64_t v);
631  MsgPackArrayWriter putArray(size_t aelemsNum);
632  MsgPackMapWriter putMap(size_t melemsNum);
633 };
634 
636 {
637 private:
638  std::vector<cxbyte>& output;
639  size_t elemsNum;
640  size_t count;
641  bool inKey;
642 public:
643  MsgPackMapWriter(size_t elemsNum, std::vector<cxbyte>& output);
644  void putKeyString(const char* str);
645  void putValueBool(bool b);
646  void putValueString(const char* str);
647  void putValueUInt(uint64_t v);
648  MsgPackArrayWriter putValueArray(size_t aelemsNum);
649  MsgPackMapWriter putValueMap(size_t melemsNum);
650  std::vector<cxbyte>& putValueElement();
651 };
652 
653 };
654 
655 #endif
ROCmAccessQual
ROCm access qualifier.
Definition: ROCmBinaries.h:122
CString format
printf format
Definition: ROCmBinaries.h:186
cxuint vgprsNum
number of VGPRs
Definition: ROCmBinaries.h:171
ROCmValueKind
ROCm Value kind.
Definition: ROCmBinaries.h:70
use 64-bit pointers
Definition: Commons.h:59
ROCm data region.
Definition: ROCmBinaries.h:61
pointer to local memory
double floating point
function kernel (code)
cxuint spilledVgprs
number of spilled VGPRs
Definition: ROCmBinaries.h:175
non copyable and non movable base structure (class)
Definition: Utilities.h:46
CString runtimeHandle
symbol of runtime handle
Definition: ROCmBinaries.h:164
uint32_t Flags
type for declaring various flags
Definition: Utilities.h:100
pointer to global memory
const ROCmInput * getInput() const
get input
Definition: ROCmBinaries.h:515
ROCmRegionType type
type
Definition: ROCmBinaries.h:66
uint64_t pointeeAlign
alignemnt of pointed data of pointer
Definition: ROCmBinaries.h:141
const char * getMetadata() const
get metadata
Definition: ROCmBinaries.h:304
none operation
size_t size
data size
Definition: ROCmBinaries.h:64
ROCm binary input structure.
Definition: ROCmBinaries.h:423
uint32_t archStepping
GPU arch stepping.
Definition: ROCmBinaries.h:427
CString symbolName
symbol name
Definition: ROCmBinaries.h:157
all ROCm binaries flags
Definition: ROCmBinaries.h:49
bool isRestrict
is restrict
Definition: ROCmBinaries.h:148
CString language
language
Definition: ROCmBinaries.h:159
ROCm printf call info.
Definition: ROCmBinaries.h:182
class ElfBinaryTemplate< Elf64Types > ElfBinary64
type for 64-bit ELF binary
Definition: ElfBinaries.h:483
CString regionName
region name
Definition: ROCmBinaries.h:63
ROCmValueKind valueKind
value kind
Definition: ROCmBinaries.h:142
AMD HSA kernel configuration structure.
Definition: Commons.h:66
common definitions for binaries
size_t offset
data
Definition: ROCmBinaries.h:65
const Array< size_t > getGotSymbols() const
get GOT symbols (indices) (from elfbin dynsymbols)
Definition: ROCmBinaries.h:356
CString target
LLVM target triple with device name.
Definition: ROCmBinaries.h:439
Definition: ROCmBinaries.h:635
size_t getKernelInfosNum() const
get kernel metadata infos number
Definition: ROCmBinaries.h:319
64-bit unsigned integer
const ROCmRegion & getRegion(size_t index) const
get region by index
Definition: ROCmBinaries.h:273
const ROCmKernelMetadata & getKernelInfo(size_t index) const
get kernel metadata info
Definition: ROCmBinaries.h:323
size_t globalDataSize
global data size
Definition: ROCmBinaries.h:432
Array< uint32_t > argSizes
unique id of call
Definition: ROCmBinaries.h:185
create metadata info object
Definition: ROCmBinaries.h:47
Configuration header.
cxuint spilledSgprs
number of spilled SGPRs
Definition: ROCmBinaries.h:174
uint64_t align
argument alignment in bytes
Definition: ROCmBinaries.h:138
ROCmValueType
ROCm argument&#39;s value type.
Definition: ROCmBinaries.h:91
size_t getSectionOffset(cxuint sectionId) const
get section offset (from main section)
Definition: ROCmBinaries.h:523
size_t getMetadataSize() const
get metadata size
Definition: ROCmBinaries.h:301
uint64_t kernargSegmentSize
kernel argument segment size
Definition: ROCmBinaries.h:165
ROCmAccessQual actualAccessQual
actual access qualifier
Definition: ROCmBinaries.h:146
std::vector< ROCmKernelArgInfo > argInfos
kernel arguments
Definition: ROCmBinaries.h:158
bool newBinFormat
use new binary format for ROCm
Definition: ROCmBinaries.h:429
size_t getCodeSize() const
get code size
Definition: ROCmBinaries.h:280
std::vector< BinSymbol > extraSymbols
extra symbols
Definition: ROCmBinaries.h:453
use kernel argument segment pointer
Definition: Commons.h:46
cxbyte * getGlobalData()
get global data
Definition: ROCmBinaries.h:297
CString name
name
Definition: ROCmBinaries.h:134
single floating point
32-bit signed integer
ROCm main binary for GPU for 64-bit mode.
Definition: ROCmBinaries.h:234
use ordered append gds
Definition: Commons.h:58
std::vector< ROCmKernelMetadata > kernels
kernel metadatas
Definition: ROCmBinaries.h:194
bool isConst
is constant
Definition: ROCmBinaries.h:147
bool isROCmBinary(size_t binarySize, const cxbyte *binary)
check whether is Amd OpenCL 2.0 binary
ROCmAccessQual accessQual
access qualifier (for images and values)
Definition: ROCmBinaries.h:145
const char * metadata
metadata
Definition: ROCmBinaries.h:442
CString symbolName
symbol name
Definition: ROCmBinaries.h:416
creation flags for ELF binaries
Definition: ElfBinaries.h:73
input output utilities
ROCmMetadata metadataInfo
metadata info
Definition: ROCmBinaries.h:444
std::vector< size_t > gotSymbols
list of indices of symbols to GOT section
Definition: ROCmBinaries.h:451
Definition: ROCmBinaries.h:583
CString vecTypeHint
vector type hint
Definition: ROCmBinaries.h:163
size_t codeSize
code size
Definition: ROCmBinaries.h:435
xnack enabled
Definition: Commons.h:62
bool isVolatile
is volatile
Definition: ROCmBinaries.h:149
unsigned char cxbyte
unsigned byte
Definition: Config.h:229
const cxbyte * code
code
Definition: ROCmBinaries.h:436
bool isPipe
is pipe
Definition: ROCmBinaries.h:150
use workgroup count for Y dim
Definition: Commons.h:52
main namespace
Definition: AsmDefs.h:38
size_t getGlobalDataSize() const
get global data size
Definition: ROCmBinaries.h:290
ROCmRegionType
ROCm region/symbol type.
Definition: ROCmBinaries.h:53
Array< std::pair< CString, size_t > > RegionMap
region map type
Definition: ROCmBinaries.h:238
ROCm kernel metadata.
Definition: ROCmBinaries.h:154
ROCm binary metadata.
Definition: ROCmBinaries.h:190
cxbyte * getCode()
get code
Definition: ROCmBinaries.h:286
unsigned int cxuint
unsigned int
Definition: Config.h:237
uint32_t eflags
ELF headef e_flags field.
Definition: ROCmBinaries.h:428
use private segment buffer
Definition: Commons.h:43
const char * comment
comment
Definition: ROCmBinaries.h:438
OpenCL kernel to call ??
cxuint wavefrontSize
wavefront size
Definition: ROCmBinaries.h:169
size_t getGotSymbolsNum() const
get GOT symbol index (from elfbin dynsymbols)
Definition: ROCmBinaries.h:352
passed in global buffer
bool isNewBinaryFormat() const
return true is new binary format
Definition: ROCmBinaries.h:340
std::vector< ROCmPrintfInfo > printfInfos
printf calls infos
Definition: ROCmBinaries.h:193
ROCm kernel argument.
Definition: ROCmBinaries.h:132
use private segment size
Definition: Commons.h:49
inlines for accessing memory words in LittleEndian and unaligned
const cxbyte * globalData
global data
Definition: ROCmBinaries.h:433
32-bit unsigned integer
ROCm binary symbol input.
Definition: ROCmBinaries.h:414
GPUDeviceType
type of GPU device
Definition: GPUId.h:51
const cxbyte * getCode() const
get code
Definition: ROCmBinaries.h:283
ROCm binary generator.
Definition: ROCmBinaries.h:460
ROCmValueType valueType
value type
Definition: ROCmBinaries.h:143
std::vector< ROCmSymbolInput > symbols
symbols
Definition: ROCmBinaries.h:434
utilities for other libraries and programs
bool hasKernelInfoMap() const
returns true if object has kernel map
Definition: ROCmBinaries.h:367
passed as dynamic shared pointer
uint64_t privateSegmentFixedSize
private segment size (fixed)
Definition: ROCmBinaries.h:167
const CString & getTarget() const
get target
Definition: ROCmBinaries.h:336
Definition: ROCmBinaries.h:553
uint32_t archMinor
GPU arch minor.
Definition: ROCmBinaries.h:426
size_t metadataSize
metadata size
Definition: ROCmBinaries.h:441
ROCmRegionType type
type
Definition: ROCmBinaries.h:419
bool hasMetadataInfo() const
has metadata info
Definition: ROCmBinaries.h:311
Definition: ROCmBinaries.h:619
create region map
Definition: ROCmBinaries.h:46
64-bit signed integer
bool hasRegionMap() const
returns true if kernel map exists
Definition: ROCmBinaries.h:364
use workgroup count for X dim
Definition: Commons.h:51
CString targetTripple
same LLVM target tripple
Definition: ROCmBinaries.h:440
GPU identification utilities.
size_t size() const
returns number of elements
Definition: Containers.h:172
use queue pointer
Definition: Commons.h:45
size_t size
size of symbol
Definition: ROCmBinaries.h:418
ROCmAddressSpace
ROCm argument address space.
Definition: ROCmBinaries.h:109
CString name
kernel name
Definition: ROCmBinaries.h:156
GPUDeviceType deviceType
GPU device type.
Definition: ROCmBinaries.h:425
kernel or global data
size_t getRegionsNum() const
get regions number
Definition: ROCmBinaries.h:269
cxuint sgprsNum
number of SGPRs
Definition: ROCmBinaries.h:170
value is just value
bool isMetadataV3Format() const
return true is metadata V3 code object format
Definition: ROCmBinaries.h:348
ROCmAddressSpace addressSpace
pointer address space
Definition: ROCmBinaries.h:144
void SLEV(uint8_t &r, uint8_t v)
save from/to little endian value
Definition: MemAccess.h:246
use workgroup count for Z dim
Definition: Commons.h:53
create kernel metadata info map
Definition: ROCmBinaries.h:48
size_t getGotSymbol(size_t index) const
get GOT symbol index (from elfbin dynsymbols)
Definition: ROCmBinaries.h:360
const ROCmMetadata & getMetadataInfo() const
get metadata info
Definition: ROCmBinaries.h:315
const cxbyte * getGlobalData() const
get global data
Definition: ROCmBinaries.h:294
bool isLLVM10BinaryFormat() const
return true is LLVM10 binary format
Definition: ROCmBinaries.h:344
uint64_t kernargSegmentAlign
alignment of kernel argument segment
Definition: ROCmBinaries.h:168
Definition: ROCmBinaries.h:204
std::vector< BinSection > extraSections
extra sections
Definition: ROCmBinaries.h:452
bool useMetadataInfo
use metadatainfo instead same metadata
Definition: ROCmBinaries.h:443
size_t offset
offset in code
Definition: ROCmBinaries.h:417
Elf binaries handling.
simple C-string container
Definition: CString.h:38
Elf.h definitions.
const ROCmKernelDescriptor * getKernelDescriptor(size_t index) const
get kernel descriptor
Definition: ROCmBinaries.h:330
containers and other utils for other libraries and programs
CString typeName
type name
Definition: ROCmBinaries.h:135
uint64_t size
argument size in bytes
Definition: ROCmBinaries.h:136
char * getMetadata()
get metadata
Definition: ROCmBinaries.h:307
size_t commentSize
comment size (can be null)
Definition: ROCmBinaries.h:437
debug enabled
Definition: Commons.h:61
pointer to constant memory
uint64_t groupSegmentFixedSize
group segment size (fixed)
Definition: ROCmBinaries.h:166
AmdHsaKernelConfig ROCmKernelConfig
ROCm kernel configuration structure.
Definition: ROCmBinaries.h:394