include/hip/driver_types.h Source File

include/hip/driver_types.h Source File#

HIP Runtime API Reference: include/hip/driver_types.h Source File
/*
 * Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
 *
 * SPDX-License-Identifier: MIT
 */
 
#ifndef HIP_INCLUDE_HIP_DRIVER_TYPES_H
#define HIP_INCLUDE_HIP_DRIVER_TYPES_H
 
#if !defined(__HIPCC_RTC__)
#include <hip/hip_common.h>
#if __cplusplus
#include <cstdlib>
#else
#include <stdlib.h>  // size_t
#endif
#endif
 
#if !defined(__HIP_PLATFORM_AMD__) && defined(__HIP_PLATFORM_NVIDIA__)
#include "driver_types.h"
#elif defined(__HIP_PLATFORM_AMD__) && !defined(__HIP_PLATFORM_NVIDIA__)
 
typedef void* hipDeviceptr_t;
typedef enum hipChannelFormatKind {
  hipChannelFormatKindSigned = 0,    
  hipChannelFormatKindUnsigned = 1,  
  hipChannelFormatKindFloat = 2,     
  hipChannelFormatKindNone = 3       
} hipChannelFormatKind;
typedef struct hipChannelFormatDesc {
  int x;
  int y;
  int z;
  int w;
  enum hipChannelFormatKind f;  
} hipChannelFormatDesc;
#define HIP_TRSA_OVERRIDE_FORMAT 0x01
#define HIP_TRSF_READ_AS_INTEGER 0x01
#define HIP_TRSF_NORMALIZED_COORDINATES 0x02
#define HIP_TRSF_SRGB 0x10
 
typedef struct hipArray* hipArray_t;
typedef const struct hipArray* hipArray_const_t;
typedef enum hipArray_Format {
  HIP_AD_FORMAT_UNSIGNED_INT8 = 0x01,   
  HIP_AD_FORMAT_UNSIGNED_INT16 = 0x02,  
  HIP_AD_FORMAT_UNSIGNED_INT32 = 0x03,  
  HIP_AD_FORMAT_SIGNED_INT8 = 0x08,     
  HIP_AD_FORMAT_SIGNED_INT16 = 0x09,    
  HIP_AD_FORMAT_SIGNED_INT32 = 0x0a,    
  HIP_AD_FORMAT_HALF = 0x10,            
  HIP_AD_FORMAT_FLOAT = 0x20            
} hipArray_Format;
typedef struct HIP_ARRAY_DESCRIPTOR {
  size_t Width;                 
  size_t Height;                
  enum hipArray_Format Format;  
  unsigned int NumChannels;     
} HIP_ARRAY_DESCRIPTOR;
 
typedef struct HIP_ARRAY3D_DESCRIPTOR {
  size_t Width;                 
  size_t Height;                
  size_t Depth;                 
  enum hipArray_Format Format;  
  unsigned int NumChannels;     
  unsigned int Flags;           
} HIP_ARRAY3D_DESCRIPTOR;
#if !defined(__HIPCC_RTC__)
typedef struct hip_Memcpy2D {
  size_t srcXInBytes;           
  size_t srcY;                  
  hipMemoryType srcMemoryType;  
  const void* srcHost;          
  hipDeviceptr_t srcDevice;     
  hipArray_t srcArray;          
  size_t srcPitch;              
  size_t dstXInBytes;           
  size_t dstY;                  
  hipMemoryType dstMemoryType;  
  void* dstHost;                
  hipDeviceptr_t dstDevice;     
  hipArray_t dstArray;          
  size_t dstPitch;              
  size_t WidthInBytes;          
  size_t Height;                
} hip_Memcpy2D;
#endif  // !defined(__HIPCC_RTC__)
typedef struct hipMipmappedArray {
  void* data;                        
  struct hipChannelFormatDesc desc;  
  unsigned int type;                 
  unsigned int width;                
  unsigned int height;               
  unsigned int depth;                
  unsigned int min_mipmap_level;     
  unsigned int max_mipmap_level;     
  unsigned int flags;                
  enum hipArray_Format format;       
  unsigned int num_channels;         
} hipMipmappedArray;
typedef struct hipMipmappedArray* hipMipmappedArray_t;
typedef hipMipmappedArray_t hipmipmappedArray;
typedef const struct hipMipmappedArray* hipMipmappedArray_const_t;
typedef enum hipResourceType {
  hipResourceTypeArray = 0x00,           
  hipResourceTypeMipmappedArray = 0x01,  
  hipResourceTypeLinear = 0x02,          
  hipResourceTypePitch2D = 0x03          
} hipResourceType;
typedef enum HIPresourcetype_enum {
  HIP_RESOURCE_TYPE_ARRAY = 0x00,            
  HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY = 0x01,  
  HIP_RESOURCE_TYPE_LINEAR = 0x02,           
  HIP_RESOURCE_TYPE_PITCH2D = 0x03           
} HIPresourcetype,
    hipResourcetype;
typedef enum HIPaddress_mode_enum {
  HIP_TR_ADDRESS_MODE_WRAP = 0,    
  HIP_TR_ADDRESS_MODE_CLAMP = 1,   
  HIP_TR_ADDRESS_MODE_MIRROR = 2,  
  HIP_TR_ADDRESS_MODE_BORDER = 3   
} HIPaddress_mode;
typedef enum HIPfilter_mode_enum {
  HIP_TR_FILTER_MODE_POINT = 0,  
  HIP_TR_FILTER_MODE_LINEAR = 1  
} HIPfilter_mode;
typedef struct HIP_TEXTURE_DESC_st {
  HIPaddress_mode addressMode[3];   
  HIPfilter_mode filterMode;        
  unsigned int flags;               
  unsigned int maxAnisotropy;       
  HIPfilter_mode mipmapFilterMode;  
  float mipmapLevelBias;            
  float minMipmapLevelClamp;        
  float maxMipmapLevelClamp;        
  float borderColor[4];             
  int reserved[12];
} HIP_TEXTURE_DESC;
typedef enum hipResourceViewFormat {
  hipResViewFormatNone = 0x00,  
  hipResViewFormatUnsignedChar1 = 0x01,              
  hipResViewFormatUnsignedChar2 = 0x02,              
  hipResViewFormatUnsignedChar4 = 0x03,              
  hipResViewFormatSignedChar1 = 0x04,                
  hipResViewFormatSignedChar2 = 0x05,                
  hipResViewFormatSignedChar4 = 0x06,                
  hipResViewFormatUnsignedShort1 = 0x07,             
  hipResViewFormatUnsignedShort2 = 0x08,             
  hipResViewFormatUnsignedShort4 = 0x09,             
  hipResViewFormatSignedShort1 = 0x0a,               
  hipResViewFormatSignedShort2 = 0x0b,               
  hipResViewFormatSignedShort4 = 0x0c,               
  hipResViewFormatUnsignedInt1 = 0x0d,               
  hipResViewFormatUnsignedInt2 = 0x0e,               
  hipResViewFormatUnsignedInt4 = 0x0f,               
  hipResViewFormatSignedInt1 = 0x10,                 
  hipResViewFormatSignedInt2 = 0x11,                 
  hipResViewFormatSignedInt4 = 0x12,                 
  hipResViewFormatHalf1 = 0x13,                      
  hipResViewFormatHalf2 = 0x14,                      
  hipResViewFormatHalf4 = 0x15,                      
  hipResViewFormatFloat1 = 0x16,                     
  hipResViewFormatFloat2 = 0x17,                     
  hipResViewFormatFloat4 = 0x18,                     
  hipResViewFormatUnsignedBlockCompressed1 = 0x19,   
  hipResViewFormatUnsignedBlockCompressed2 = 0x1a,   
  hipResViewFormatUnsignedBlockCompressed3 = 0x1b,   
  hipResViewFormatUnsignedBlockCompressed4 = 0x1c,   
  hipResViewFormatSignedBlockCompressed4 = 0x1d,     
  hipResViewFormatUnsignedBlockCompressed5 = 0x1e,   
  hipResViewFormatSignedBlockCompressed5 = 0x1f,     
  hipResViewFormatUnsignedBlockCompressed6H = 0x20,  
  hipResViewFormatSignedBlockCompressed6H = 0x21,    
  hipResViewFormatUnsignedBlockCompressed7 = 0x22    
} hipResourceViewFormat;
typedef enum HIPresourceViewFormat_enum {
  HIP_RES_VIEW_FORMAT_NONE = 0x00,  
  HIP_RES_VIEW_FORMAT_UINT_1X8 = 0x01,       
  HIP_RES_VIEW_FORMAT_UINT_2X8 = 0x02,       
  HIP_RES_VIEW_FORMAT_UINT_4X8 = 0x03,       
  HIP_RES_VIEW_FORMAT_SINT_1X8 = 0x04,       
  HIP_RES_VIEW_FORMAT_SINT_2X8 = 0x05,       
  HIP_RES_VIEW_FORMAT_SINT_4X8 = 0x06,       
  HIP_RES_VIEW_FORMAT_UINT_1X16 = 0x07,      
  HIP_RES_VIEW_FORMAT_UINT_2X16 = 0x08,      
  HIP_RES_VIEW_FORMAT_UINT_4X16 = 0x09,      
  HIP_RES_VIEW_FORMAT_SINT_1X16 = 0x0a,      
  HIP_RES_VIEW_FORMAT_SINT_2X16 = 0x0b,      
  HIP_RES_VIEW_FORMAT_SINT_4X16 = 0x0c,      
  HIP_RES_VIEW_FORMAT_UINT_1X32 = 0x0d,      
  HIP_RES_VIEW_FORMAT_UINT_2X32 = 0x0e,      
  HIP_RES_VIEW_FORMAT_UINT_4X32 = 0x0f,      
  HIP_RES_VIEW_FORMAT_SINT_1X32 = 0x10,      
  HIP_RES_VIEW_FORMAT_SINT_2X32 = 0x11,      
  HIP_RES_VIEW_FORMAT_SINT_4X32 = 0x12,      
  HIP_RES_VIEW_FORMAT_FLOAT_1X16 = 0x13,     
  HIP_RES_VIEW_FORMAT_FLOAT_2X16 = 0x14,     
  HIP_RES_VIEW_FORMAT_FLOAT_4X16 = 0x15,     
  HIP_RES_VIEW_FORMAT_FLOAT_1X32 = 0x16,     
  HIP_RES_VIEW_FORMAT_FLOAT_2X32 = 0x17,     
  HIP_RES_VIEW_FORMAT_FLOAT_4X32 = 0x18,     
  HIP_RES_VIEW_FORMAT_UNSIGNED_BC1 = 0x19,   
  HIP_RES_VIEW_FORMAT_UNSIGNED_BC2 = 0x1a,   
  HIP_RES_VIEW_FORMAT_UNSIGNED_BC3 = 0x1b,   
  HIP_RES_VIEW_FORMAT_UNSIGNED_BC4 = 0x1c,   
  HIP_RES_VIEW_FORMAT_SIGNED_BC4 = 0x1d,     
  HIP_RES_VIEW_FORMAT_UNSIGNED_BC5 = 0x1e,   
  HIP_RES_VIEW_FORMAT_SIGNED_BC5 = 0x1f,     
  HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H = 0x20,  
  HIP_RES_VIEW_FORMAT_SIGNED_BC6H = 0x21,    
  HIP_RES_VIEW_FORMAT_UNSIGNED_BC7 = 0x22    
} HIPresourceViewFormat;
typedef struct hipResourceDesc {
  enum hipResourceType resType;  
  union {
    struct {
      hipArray_t array;  
    } array;
    struct {
      hipMipmappedArray_t mipmap;  
    } mipmap;
    struct {
      void* devPtr;                      
      struct hipChannelFormatDesc desc;  
      size_t sizeInBytes;                
    } linear;
    struct {
      void* devPtr;                      
      struct hipChannelFormatDesc desc;  
      size_t width;                      
      size_t height;                     
      size_t pitchInBytes;               
    } pitch2D;
  } res;
} hipResourceDesc;
 
typedef struct HIP_RESOURCE_DESC_st {
  HIPresourcetype resType;  
  union {
    struct {
      hipArray_t hArray;  
    } array;
    struct {
      hipMipmappedArray_t hMipmappedArray;  
    } mipmap;
    struct {
      hipDeviceptr_t devPtr;     
      hipArray_Format format;    
      unsigned int numChannels;  
      size_t sizeInBytes;        
    } linear;
    struct {
      hipDeviceptr_t devPtr;     
      hipArray_Format format;    
      unsigned int numChannels;  
      size_t width;              
      size_t height;             
      size_t pitchInBytes;       
    } pitch2D;
    struct {
      int reserved[32];
    } reserved;
  } res;
  unsigned int flags;  
} HIP_RESOURCE_DESC;
struct hipResourceViewDesc {
  enum hipResourceViewFormat format;  
  size_t width;                       
  size_t height;                      
  size_t depth;                       
  unsigned int firstMipmapLevel;      
  unsigned int lastMipmapLevel;       
  unsigned int firstLayer;            
  unsigned int lastLayer;             
};
typedef struct HIP_RESOURCE_VIEW_DESC_st {
  HIPresourceViewFormat format;   
  size_t width;                   
  size_t height;                  
  size_t depth;                   
  unsigned int firstMipmapLevel;  
  unsigned int lastMipmapLevel;   
  unsigned int firstLayer;        
  unsigned int lastLayer;         
  unsigned int reserved[16];
} HIP_RESOURCE_VIEW_DESC;
#if !defined(__HIPCC_RTC__)
typedef enum hipMemcpyKind {
  hipMemcpyHostToHost = 0,            
  hipMemcpyHostToDevice = 1,          
  hipMemcpyDeviceToHost = 2,          
  hipMemcpyDeviceToDevice = 3,        
  hipMemcpyDefault = 4,               
  hipMemcpyDeviceToDeviceNoCU = 1024  
} hipMemcpyKind;
typedef struct hipPitchedPtr {
  void* ptr;     
  size_t pitch;  
  size_t xsize;  
  size_t ysize;  
} hipPitchedPtr;
typedef struct hipExtent {
  size_t width;  // Width in elements when referring to array memory, in bytes when referring to
                 // linear memory
  size_t height;
  size_t depth;
} hipExtent;
typedef struct hipPos {
  size_t x;  
  size_t y;  
  size_t z;  
} hipPos;
typedef struct hipMemcpy3DParms {
  hipArray_t srcArray;          
  struct hipPos srcPos;         
  struct hipPitchedPtr srcPtr;  
  hipArray_t dstArray;          
  struct hipPos dstPos;         
  struct hipPitchedPtr dstPtr;  
  struct hipExtent extent;      
  enum hipMemcpyKind kind;      
} hipMemcpy3DParms;
typedef struct HIP_MEMCPY3D {
  size_t srcXInBytes;           
  size_t srcY;                  
  size_t srcZ;                  
  size_t srcLOD;                
  hipMemoryType srcMemoryType;  
  const void* srcHost;          
  hipDeviceptr_t srcDevice;     
  hipArray_t srcArray;          
  size_t srcPitch;              
  size_t srcHeight;             
  size_t dstXInBytes;           
  size_t dstY;                  
  size_t dstZ;                  
  size_t dstLOD;                
  hipMemoryType dstMemoryType;  
  void* dstHost;                
  hipDeviceptr_t dstDevice;     
  hipArray_t dstArray;          
  size_t dstPitch;              
  size_t dstHeight;             
  size_t WidthInBytes;          
  size_t Height;                
  size_t Depth;                 
} HIP_MEMCPY3D;
typedef enum hipMemLocationType {
  hipMemLocationTypeInvalid = 0,
  hipMemLocationTypeNone = 0,
  hipMemLocationTypeDevice = 1,    
  hipMemLocationTypeHost = 2,      
  hipMemLocationTypeHostNuma = 3,  
  hipMemLocationTypeHostNumaCurrent =
      4  
} hipMemLocationType;
typedef struct hipMemLocation {
  hipMemLocationType type;  
  int id;                   
} hipMemLocation;
 
typedef enum hipMemcpyFlags {
  hipMemcpyFlagDefault = 0x0,                  
  hipMemcpyFlagPreferOverlapWithCompute = 0x1, 
  hipMemcpyFlagExtPreferCE = 0x100,            
  hipMemcpyFlagExtOpSwap = 0x200,              
  hipMemcpyFlagExtOpIndirectSrc = 0x400,       
  hipMemcpyFlagExtOpIndirectDst = 0x800        
} hipMemcpyFlags;
 
typedef enum hipMemcpySrcAccessOrder {
  hipMemcpySrcAccessOrderInvalid = 0x0,  
  hipMemcpySrcAccessOrderStream = 0x1,   
  hipMemcpySrcAccessOrderDuringApiCall =
      0x2,  
  hipMemcpySrcAccessOrderAny =
      0x3,  
  hipMemcpySrcAccessOrderMax = 0x7FFFFFFF
} hipMemcpySrcAccessOrder;
 
typedef struct hipMemcpyAttributes {
  hipMemcpySrcAccessOrder
      srcAccessOrder;  
  hipMemLocation srcLocHint;  
  hipMemLocation dstLocHint;  
  unsigned int flags;         
} hipMemcpyAttributes;
typedef enum hipMemcpy3DOperandType {
  hipMemcpyOperandTypePointer = 0x1,  
  hipMemcpyOperandTypeArray = 0x2,    
  hipMemcpyOperandTypeMax = 0x7FFFFFFF
} hipMemcpy3DOperandType;
 
typedef struct hipOffset3D {
  size_t x;
  size_t y;
  size_t z;
} hipOffset3D;
typedef struct hipMemcpy3DOperand {
  hipMemcpy3DOperandType type;
  union {
    struct {
      void* ptr;
      size_t rowLength;        
      size_t layerHeight;      
      hipMemLocation locHint;  
    } ptr;
    struct {
      hipArray_t array;    
      hipOffset3D offset;  
    } array;
  } op;
} hipMemcpy3DOperand;
 
typedef struct hipMemcpy3DBatchOp {
  hipMemcpy3DOperand src;
  hipMemcpy3DOperand dst;
  hipExtent extent;
  hipMemcpySrcAccessOrder srcAccessOrder;
  unsigned int flags;
} hipMemcpy3DBatchOp;
 
typedef struct hipMemcpy3DPeerParms {
  hipArray_t srcArray;   
  hipPos srcPos;         
  hipPitchedPtr srcPtr;  
  int srcDevice;         
  hipArray_t dstArray;   
  hipPos dstPos;         
  hipPitchedPtr dstPtr;  
  int dstDevice;         
  hipExtent extent;      
} hipMemcpy3DPeerParms;
 
static inline struct hipPitchedPtr make_hipPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) {
  struct hipPitchedPtr s;
  s.ptr = d;
  s.pitch = p;
  s.xsize = xsz;
  s.ysize = ysz;
  return s;
}
static inline struct hipPos make_hipPos(size_t x, size_t y, size_t z) {
  struct hipPos p;
  p.x = x;
  p.y = y;
  p.z = z;
  return p;
}
static inline struct hipExtent make_hipExtent(size_t w, size_t h, size_t d) {
  struct hipExtent e;
  e.width = w;
  e.height = h;
  e.depth = d;
  return e;
}
 
typedef enum hipFunction_attribute {
  HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK,                 
  HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES,                     
  HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES,                      
  HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES,                      
  HIP_FUNC_ATTRIBUTE_NUM_REGS,                              
  HIP_FUNC_ATTRIBUTE_PTX_VERSION,                           
  HIP_FUNC_ATTRIBUTE_BINARY_VERSION,                        
  HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA,                         
  HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES,         
  HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT,      
  HIP_FUNC_ATTRIBUTE_CLUSTER_DIM_MUST_BE_SET,               
  HIP_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH,                
  HIP_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT,               
  HIP_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH,                
  HIP_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED,     
  HIP_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE,  
  HIP_FUNC_ATTRIBUTE_MAX
} hipFunction_attribute;
 
typedef enum hipPointer_attribute {
  HIP_POINTER_ATTRIBUTE_CONTEXT = 1,     
  HIP_POINTER_ATTRIBUTE_MEMORY_TYPE,     
  HIP_POINTER_ATTRIBUTE_DEVICE_POINTER,  
  HIP_POINTER_ATTRIBUTE_HOST_POINTER,    
  HIP_POINTER_ATTRIBUTE_P2P_TOKENS,      
  HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS,     
  HIP_POINTER_ATTRIBUTE_BUFFER_ID,       
  HIP_POINTER_ATTRIBUTE_IS_MANAGED,      
  HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL,  
  HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE,  
  HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR,           
  HIP_POINTER_ATTRIBUTE_RANGE_SIZE,  
  HIP_POINTER_ATTRIBUTE_MAPPED,      
  HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,  
  HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,  
  HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS,   
  HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE  
} hipPointer_attribute;
 
// doxygen end DriverTypes
#endif  // !defined(__HIPCC_RTC__)
#else
#error ("Must define exactly one of __HIP_PLATFORM_AMD__ or __HIP_PLATFORM_NVIDIA__");
#endif
#endif